제네릭과 컬렉션

이정현
∙∙조회 3

20261029 제네릭과 컬렉션

개요

배열은 만들 때 크기를 정하고 나면 바꿀 수 없음. 요소를 하나 더 넣으려면 더 큰 배열을 새로 만들어 전부 옮겨야 함. .NET 은 이런 일을 대신 해 주는 컬렉션(collection) 을 제공함. 그런데 컬렉션을 이해하려면 그 이름에 붙어 있는 꺾쇠 표기를 먼저 알아야 함. List<string> 의 <string> 은 “이 목록에는 string 만 담는다”는 뜻임. 이 표기를 제네릭(generic) 이라고 함.

제네릭

제네릭은 일반화와 동의어다

타입이 정해지지 않은 그릇이 필요할 때

정수를 담아 두었다가 꺼내는 상자를 만든다고 하면 int를 받는 클래스(예를 들어 IntBox클래스)를 만들어야함. 문자열도 담고 싶으면 StringBox 를 또 만들어야 함. 담을 타입마다 클래스를 만드는 것은 끝이 없음. 제네릭이 없던 시절에는 모든 타입의 조상인 object에 담아 이 문제를 피했음. 하지만 이 경우 담기는 하는데, 꺼낼 때 문제가 생김. 되돌리는 것 자체도 번거롭지만, 진짜 문제는 엉뚱한 것이 들어가 있어도 컴파일러가 막지 못한다는 점임. 잘못을 컴파일 시점이 아니라 실행 시점에 알게 됨. 프로그램이 커질수록 이런 실수는 찾기 어려워짐.

박싱과 언박싱

object 에 담을 때는 성능 문제도 함께 따라옴. int·double·bool 같은 값 타입은 값을 그 자리에 직접 갖고 있음. 반면 object 는 참조 타입이므로 값이 있는 곳을 가리키기만 함. 값 타입을 object 에 넣으려면 그 값을 힙에 새로 만들어 감싸야 하는데, 이것을 박싱(boxing) 이라고 함. 꺼내면서 되돌리는 것은 언박싱(unboxing)임. 값을 담고 꺼낼 때마다 박싱과 언박싱이 일어나므로, 많은 값을 다루면 비용이 쌓임. 박싱과 언박싱은 구조체와 연산자 오버로딩 정리할 때 적어뒀으니 여기까지만 적음.

타입을 매개변수로 받기

제네릭은 클래스를 만들 때 타입 자리를 비워 두고, 쓰는 쪽에서 채우게 하는 기능임.

csharp
// 제네릭을 통해 사용할 때 타입을 정하는 예시
Box<int> numberBox = new Box<int>();
numberBox.Content = 100;

Box<string> textBox = new Box<string>();
textBox.Content = "안녕";

Console.WriteLine(numberBox.Content + 1);
Console.WriteLine(textBox.Content + "하세요");

// T 자리는 쓰는 쪽이 채움
class Box<T>
{
    public T Content { get; set; }
}

Box<int> 의 Content 는 int 이고 Box<string> 의 Content 는 string 임. 클래스는 하나인데 타입별로 알맞게 동작함.

T 는 타입을 담는 자리라는 뜻으로 관례상 쓰는 이름임. Type 의 머리글자이며, 다른 이름을 써도 됨. 타입 자리가 여럿이면 TKey, TValue 처럼 T 로 시작하는 이름을 붙여 구분함.

csharp
// T 이름 변경 예시
class Pair<TFirst, TSecond>
{
    public TFirst First { get; set; }
    public TSecond Second { get; set; }

    public Pair(TFirst first, TSecond second)
    {
        First = first;
        Second = second;
    }
}

무엇이 좋아졌는가

object 를 쓸 때 생기던 문제 둘이 모두 사라짐.

항목object로 담을 때제네릭
잘못된 타입 검사실행 시점컴파일 시점
꺼낼 때 형변환필요불필요
박싱, 언박싱값 타입을 object로 담을 때 발생T로 저장, 반환하는 이 경로에서는 불필요

제네릭 메서드

클래스 전체가 아니라 메서드 하나만

타입만 다르고 하는 일이 같은 메서드가 여럿 생기는 경우가 있음.

csharp
// 타입만 다르고 하는 일이 같은 메서드 예시
static void SwapInt(ref int x, ref int y)
{
    int temp = x;
    x = y;
    y = temp;
}

static void SwapString(ref string x, ref string y)
{
    string temp = x;
    x = y;
    y = temp;
}

두 메서드의 차이는 타입 이름뿐임. 메서드 이름 뒤에 <T> 를 붙이면 하나로 합쳐짐.

타입 추론

Swap(ref a, ref b) 라고만 적었는데 동작했음. 넘긴 인수의 타입을 보고 컴파일러가 T 를 알아내기 때문임. 이것을 타입 추론 이라고 함.

명시적으로 적을 수도 있음. 다음 두 표기는 같은 뜻임. 인수만 보고는 알 수 없는 경우에는 명시해야 함.

csharp
// 같은 뜻을 가진 표기
Swap<int>(ref a, ref b);      // 명시
Swap(ref a, ref b);           // 추론
static void Swap<T>(ref T x, ref T y)
{
    T temp = x;
    x = y;
    y = temp;
}

// 명시해야만 하는 상황 예시
int[] numbers = MakeArray<int>(3);      // 명시하지 않으면 MakeArray(3)
string[] texts = MakeArray<string>(2);  // 명시하지 않으면 MakeArray(2)

// 매개변수에 T 가 없으므로 추론할 근거가 없음
static T[] MakeArray<T>(int size)
{
    return new T[size];
}

타입 제약

아무 타입이나 오면 곤란할 때

T 자리에 무엇이든 올 수 있다는 것은 무엇이든 온다고 가정하고 코드를 써야 한다는 뜻이기도 함. 두 값 중 큰 것을 돌려주려 해도 비교할 수 없음.

csharp
// 타입 제약이 필요할 수도 있는 상황 예시
// 예를 들어 T의 자리에 사용자 정의 class가 들어온다고 가정할 때
// 해당 class에 `>`를 통한 비교에 대하여 구현을 해놓지 않았다면 `>` 를 사용할 수 없음.
// 때문에 컴파일 에러 발생
static T GetMax<T>(T a, T b)
{
    return a > b ? a : b;
}

T 에 무엇이 올지 모르므로 > 를 쓸 수 있다고 장담할 수 없음. 타입 제약(constraint) 은 “이런 타입만 온다”고 미리 약속해 이 문제를 푸는 장치임. where 로 적음.

제약뜻
where T : struct값 타입만
where T : class참조 타입만
where T : new()매개변수 없는 생성자가 있는 타입만
where T : 기반클래스그 클래스이거나 그것을 상속한 타입만
where T : 인터페이스그 인터페이스를 구현한 타입만

인터페이스 제약

IComparable<T>는 “자기와 같은 타입끼리 순서를 비교할 수 있음”을 나타내는 인터페이스임. int, double, string, DateTime 등이 모두 구현하고 있음.

csharp
// IComparable 타입 제약 사용 예시
static T GetMax<T>(T a, T b) where T : IComparable<T>
{
    return a.CompareTo(b) > 0 ? a : b;
}

제약을 걸었으므로 CompareTo 를 쓸 수 있음. 제약이 없으면 그 메서드가 있다고 볼 근거가 없어 컴파일되지 않음. 제약을 만족하지 않는 타입을 넘기면 그 자리에서 막힘(컴파일되지 않음).

값 타입 제약과 참조 타입 제약

csharp
// 값 타입 제약에 각각 값타입과 참조타입을 넣을 경우 예시
NumberBox<int> intBox = new NumberBox<int>();       // 문제 없음
NumberBox<string> box = new NumberBox<string>();    // 에러 발생

class NumberBox<T> where T : struct
{
    public T Value { get; set; }
}

선언쪽 <string>과 new쪽 <string> 두 자리가 모두 걸리므로 같은 컴파일 에러 메시지가 두 번 남.

생성자 제약

T 의 인스턴스를 만들어야 하면 new() 제약이 필요함.

csharp
// 생성자 제약 예시
Monster m = Create<Monster>();
Chest c = Create<Chest>();

// 매개변수 없는 생성자가 있는 타입만 받음
static T Create<T>() where T : new()
{
    return new T();
}

class Monster
{
    public string Name { get; set; } = "슬라임";
    public int Hp { get; set; } = 50;
}

class Chest
{
    public string Label { get; set; } = "나무 상자";
}

제약 없이 new T() 를 쓰면 막힘. 그 타입에 매개변수 없는 생성자가 있다고 볼 근거가 없기 때문임.

제약 여러 개 걸기

쉼표로 이어 적음. class, struct 는 맨 앞, new() 는 맨 뒤에 와야 함.

csharp
// 여러개의 제약을 거는 예시
Console.WriteLine(Describe<Item>());

static string Describe<T>() where T : class, IShowable, new()
{
    T item = new T();
    return item.Show();
}

interface IShowable
{
    string Show();
}

class Item : IShowable
{
    public string Show() => "아이템 하나";
}

타입 자리가 여럿이면 where 를 자리마다 따로 적음. 하나에 몰아 쓰지 않음.

csharp
// 타입별 제약 예시
Slot<Sword, int> slot = new Slot<Sword, int>();
slot.Item = new Sword();
slot.Count = 3;

Console.WriteLine(slot.Describe());

// TItem 은 참조 타입, TCount 는 값 타입만 받음
class Slot<TItem, TCount>
    where TItem : class, new()
    where TCount : struct
{
    public TItem Item { get; set; }
    public TCount Count { get; set; }

    public string Describe()
    {
        return $"{Item} x {Count}";
    }
}

class Sword
{
    public override string ToString()
    {
        return "강철검";
    }
}

TItem 에는 참조 타입이면서 매개변수 없는 생성자가 있는 타입만, TCount 에는 값 타입만 올 수 있음.

제네릭 클래스 더 만들기

T의 기본값 - default

T 자리에 무엇이 올지 모르는 채로 “빈 값”을 넣어야 할 때가 있음. null 을 적으면 막힘. T 에 int 가 오면 null 이 될 수 없기 때문임. 타입에 맞는 빈 값을 얻는 장치가 default(T) 임.

csharp
// default 사용 예시
Console.WriteLine(GetDefault<int>());
Console.WriteLine(GetDefault<double>());
Console.WriteLine(GetDefault<bool>());
Console.WriteLine(GetDefault<string>() == null);

static T GetDefault<T>()
{
    return default(T);
}

타입마다 기본값이 다름.

타입기본값
숫자 타입(int, double 등)0
boolfalse
char\0
참조 타입(string, 클래스)null
구조체모든 필드가 각자의 기본 값인 상태

new T[크기] 로 만든 배열의 칸도 모두 이 값으로 채워져 있음.

csharp
// 배열에 default값 할당하는 예시
Inventory<string> bag = new Inventory<string>(3);
Inventory<int> counts = new Inventory<int>(3);

class Inventory<T>
{
    private T[] slots;

    public Inventory(int size)
    {
        slots = new T[size];
    }

    public void Set(int index, T item)
    {
        slots[index] = item;
    }

    // 타입에 맞는 빈 값으로 되돌림
    public void Clear(int index)
    {
        slots[index] = default(T);
    }

    public void PrintAll()
    {
        for (int i = 0; i < slots.Length; i++)
        {
            Console.WriteLine($"슬롯 {i}: [{slots[i]}]");
        }
    }
}

Inventory<string> 의 빈 칸은 null 이라 아무것도 찍히지 않고, Inventory<int> 의 빈 칸은 0 이 찍힘. 같은 default(T) 가 타입에 따라 다른 값이 되는 것임. 컴파일러가 T 를 알 수 있는 자리에서는 괄호를 생략하고 default 만 적어도 됨.

제네릭 클래스를 상속하기

제네릭 클래스도 상속할 수 있음. 부모의 타입 자리를 어떻게 다루느냐에 따라 모양이 갈림. 첫째는 타입 자리를 그대로 물려받는 것임. 자식도 제네릭 클래스가 됨.

csharp
// 제네릭 클래스 상속 예시
class Storage<T>
{
    protected T item;

    public virtual void Store(T item)
    {
        this.item = item;
    }

    public virtual T Get()
    {
        return this.item;
    }
}

// T 를 그대로 넘겨받음
class LoggingStorage<T> : Storage<T>
{
    public override void Store(T item)
    {
        Console.WriteLine($"[기록] 넣음: {item}");
        base.Store(item);
    }

    public override T Get()
    {
        Console.WriteLine($"[기록] 꺼냄: {this.item}");
        return base.Get();
    }
}

LoggingStorage<string> 이라고 쓰면 그 string 이 Storage<T> 의 T 자리로 그대로 전달됨. protected 로 둔 item 은 자식에서 T 타입으로 보임.

타입을 정해 놓고 상속하기

둘째는 부모의 타입 자리를 자식이 채워 버리는 것임. 자식은 더 이상 제네릭이 아님.

csharp
// 자식 클래스에서 타입을 확정시켜놓는 예시
class Storage<T>
{
    protected T item;

    public virtual void Store(T item)
    {
        this.item = item;
    }

    public virtual T Get()
    {
        return item;
    }
}

// T 자리를 int 로 못 박음
class IntStorage : Storage<int>
{
    public int Twice()
    {
        return item * 2;
    }
}

IntStorage 안에서 item 은 int 로 확정되어 있으므로 * 2 같은 계산을 그냥 할 수 있음. Storage<T> 안에서는 T 가 무엇일지 몰라 못 하던 일임.

타입 자리를 하나 더 늘리기

셋째는 부모의 타입 자리를 물려받으면서 자식이 자리를 더 붙이는 것임.

csharp
// 자식 클래스에서 추가로 제네릭을 더하는 예시
class Storage<T>
{
    protected T item;

    public virtual void Store(T item)
    {
        this.item = item;
    }

    public virtual T Get()
    {
        return item;
    }
}

// T 는 부모에게 넘기고 TTag 는 자기가 씀
class TaggedStorage<T, TTag> : Storage<T>
{
    public TTag Tag { get; set; }

    public void Print()
    {
        Console.WriteLine($"[{Tag}] {item}");
    }
}

상속 모양선언자식
타입 자리를 그대로 물려받음class Child<T> : Parent<T>제네릭 클래스
타입을 정해놓음class Child : Parent<int>보통 클래스
자리를 더 붙임class Child<T, TTag> : Parent<T>제네릭 클래스

정적 멤버는 닫힌 타입마다 따로임

Storage<int> 와 Storage<string> 은 서로 다른 타입임. 그래서 제네릭 클래스에 static 멤버를 두면 그 값도 타입마다 따로 생김.

csharp
// 타입별 static 멤버 공유 예시
Tracker<int> a = new Tracker<int>();
Tracker<int> b = new Tracker<int>();
Tracker<int> c = new Tracker<int>();
Tracker<string> d = new Tracker<string>();
Tracker<bool> e = new Tracker<bool>();
Tracker<bool> f = new Tracker<bool>();

Tracker<int>.PrintCount();                                  // 출력 결과 총 3개
Tracker<string>.PrintCount();                               // 출력 결과 총 1개
Tracker<bool>.PrintCount();                                 // 출력 결과 총 2개

Console.WriteLine($"마지막 Tracker<int> 의 번호: {c.Id}");   // 출력 결과 마지막 Tracker<int> 의 번호: 3

class Tracker<T>
{
    public static int TotalCreated { get; private set; }

    public int Id { get; private set; }

    public Tracker()
    {
        TotalCreated++;
        Id = TotalCreated;
    }

    public static void PrintCount()
    {
        Console.WriteLine($"Tracker<{typeof(T).Name}> — 총 {TotalCreated}개");
    }
}

여섯 개를 만들었는데 어느 쪽도 6이 아님. Tracker<int> 의 TotalCreated 와 Tracker<bool> 의 TotalCreated 는 이름만 같을 뿐 다른 변수임.

typeof(T).Name 은 T 자리에 실제로 들어온 타입의 이름을 돌려줌. int 가 Int32 로 찍히는 것은 그것이 .NET 에서의 정식 이름이기 때문임.

List

크기가 알아서 늘어나는 배열

List<T> 는 가장 많이 쓰는 컬렉션임. 배열과 비슷하지만 크기가 고정되어 있지 않음.(동적 배열)

하는 일배열List<T>
개수LengthCount
크기만들 때 고정넣는 대로 늘어남
요소 접근arr[0]list[0]
추가불가Add

만드는 여러 표기

csharp
// List를 생성하는 여러 표기
List<int> a = new List<int>();

// 처음부터 값을 넣어 만들기
List<string> b = new List<string> { "red", "green", "blue" };

// 배열에서 만들기
string[] arr = { "가", "나", "다" };
List<string> c = new List<string>(arr);

Console.WriteLine($"a: {a.Count}개");
Console.WriteLine($"b: {string.Join(", ", b)}");
Console.WriteLine($"c: {string.Join(", ", c)}");

넣고 빼기

csharp
// 요소를 넣고 빼는 예시
List<int> numbers = new List<int>();

// 여러 개를 한 번에
numbers.AddRange(new[] { 10, 20, 30, 40, 50 });
Console.WriteLine($"AddRange: {string.Join(", ", numbers)}");

// 자리를 지정해 끼워 넣기
numbers.Insert(0, 5);
Console.WriteLine($"Insert:   {string.Join(", ", numbers)}");

// 값으로 지우기 — 처음 만나는 하나만
numbers.Remove(30);
Console.WriteLine($"Remove:   {string.Join(", ", numbers)}");

// 자리로 지우기
numbers.RemoveAt(0);
Console.WriteLine($"RemoveAt: {string.Join(", ", numbers)}");

// 전부 비우기
numbers.Clear();
Console.WriteLine($"Clear:    {numbers.Count}개");

찾기

csharp
// 검색
List<string> names = new List<string> { "김철수", "이영희", "박민수", "이영희" };

Console.WriteLine($"포함 여부: {names.Contains("박민수")}");
Console.WriteLine($"첫 자리:   {names.IndexOf("이영희")}");
Console.WriteLine($"마지막 자리: {names.LastIndexOf("이영희")}");
Console.WriteLine($"없는 것:   {names.IndexOf("최지우")}");

없으면 -1이 반환됨

조건으로 다루기

List<T> 는 델리게이트를 받는 메서드를 여럿 갖고 있음. 조건을 람다식으로 넘기면 반복문을 직접 쓰지 않아도 됨.

csharp
// 반복문을 쓰지 않고 람다식으로 적는 예시
List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

Console.WriteLine($"첫 짝수: {numbers.Find(n => n % 2 == 0)}");
Console.WriteLine($"모든 짝수: {string.Join(", ", numbers.FindAll(n => n % 2 == 0))}");
Console.WriteLine($"8 초과 있는가: {numbers.Exists(n => n > 8)}");
Console.WriteLine($"모두 양수인가: {numbers.TrueForAll(n => n > 0)}");
Console.WriteLine($"7의 자리: {numbers.FindIndex(n => n == 7)}");

int removed = numbers.RemoveAll(n => n % 2 == 0);
Console.WriteLine($"짝수 {removed}개 제거 -> {string.Join(", ", numbers)}");

순회 중에 고치면 안 됨

foreach 로 도는 중에 요소를 넣거나 빼면 실행 중에 멈춤. 조건에 맞는 것을 지우려면 RemoveAll 을 쓰거나, 뒤에서부터 도는 for 문을 씀.

csharp
// 뒤에서부터 도는 for 문으로 삭제하는 예시
List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };

// 뒤에서부터 지우면 앞쪽 자리가 밀리지 않음
for (int i = numbers.Count - 1; i >= 0; i--)
{
    if (numbers[i] % 2 == 0)
    {
        numbers.RemoveAt(i);
    }
}

Console.WriteLine(string.Join(", ", numbers));

Dictionary<TKey, TValue>

자리 변호가 아니라 이름으로 찾기

배열과 List<T> 는 0, 1, 2 같은 자리 번호로 요소를 찾음. 그런데 “김철수의 점수”처럼 번호가 아닌 것으로 찾고 싶을 때가 있음. Dictionary<TKey, TValue> 는 키(key)와 값(value)을 짝지어 저장하고, 키로 값을 찾음.

csharp
// Dictionary를 통한 순회 및 출력 예시
Dictionary<string, int> scores = new Dictionary<string, int>();

scores["김철수"] = 85;
scores["이영희"] = 92;
scores.Add("박민수", 78);

Console.WriteLine($"인원: {scores.Count}");
Console.WriteLine($"이영희: {scores["이영희"]}점");

foreach (KeyValuePair<string, int> pair in scores)  // foreach (var pair in scores) 가능
{
    Console.WriteLine($"  {pair.Key}: {pair.Value}점");
}

foreach 로 돌면 키와 값이 짝으로 묶인 KeyValuePair<TKey, TValue> 가 나옴. var 로 받으면 타입 이름을 적지 않아도 됨.

  • 주의사항: Dictionary 를 foreach 로 돌 때 나오는 순서는 보장되지 않음. 넣은 순서대로 나오는 것처럼 보이는 경우가 많지만 그것에 기대면 안 됨. 순서가 필요하면 정렬된 컬렉션을 쓰거나 꺼낸 뒤 정렬할 것.

Add와 인덱서의 차이

같은 키를 두 번 넣으려 할 때 동작이 다름.

표기키가 없을 때키가 이미 있을 때
dict[key] = value새로 넣음덮어씀
dict.Add(key, value)새로 넣음예외 발생

덮어쓰면 안 되는 곳에서는 Add 가 실수를 잡아 줌.

없는 키를 읽으면

읽을 때도 없는 키를 쓰면 예외가 남. 있는지 먼저 확인하거나, TryGetValue 를 씀.

csharp
// ContainsKey와 TryGetValue 차이 및 사용 예시
Dictionary<string, int> inventory = new Dictionary<string, int>
{
    { "검", 1 },
    { "물약", 5 }
};

// 방법 1: ContainsKey 로 확인하고 읽기
if (inventory.ContainsKey("검"))
{
    Console.WriteLine($"검: {inventory["검"]}개");
}

// 방법 2: TryGetValue — 확인과 읽기를 한 번에
if (inventory.TryGetValue("물약", out int count))
{
    Console.WriteLine($"물약: {count}개");
}

if (inventory.TryGetValue("방패", out int shield))
{
    Console.WriteLine($"방패: {shield}개");
}
else
{
    Console.WriteLine("방패: 없음");
}

ContainsKey 는 찾는 일을 두 번 하지만 TryGetValue 는 한 번에 끝냄. 값을 쓸 것이라면 TryGetValue 쪽이 나음.

고치고 지우기

csharp
// 수정 및 삭제 예시
Dictionary<string, string> settings = new Dictionary<string, string>
{
    { "volume", "50" },
    { "difficulty", "normal" },
    { "language", "ko" }
};

settings["volume"] = "80";          // 있으므로 덮어씀
settings["music"] = "on";           // 없으므로 새로 들어감
settings.Remove("language");

foreach (var s in settings)
{
    Console.WriteLine($"{s.Key} = {s.Value}");
}

Console.WriteLine($"language 남아 있는가: {settings.ContainsKey("language")}");

키만, 값만 꺼내기

csharp
// 키나 값만 꺼내는 예시
Dictionary<string, int> scores = new Dictionary<string, int>
{
    { "김철수", 85 },
    { "이영희", 92 },
    { "박민수", 78 }
};

Console.WriteLine($"이름: {string.Join(", ", scores.Keys)}");
Console.WriteLine($"점수: {string.Join(", ", scores.Values)}");

int total = 0;
foreach (int score in scores.Values)
{
    total += score;
}
Console.WriteLine($"합계: {total}");

개수 세기에 쓰기

문자별 등장 횟수처럼 “무엇이 몇 번”을 세는 일에 잘 맞음.

csharp
// 개수 셀때 사용하는법 예시
string text = "banana";
Dictionary<char, int> counts = new Dictionary<char, int>();

foreach (char c in text)
{
    if (counts.ContainsKey(c))
    {
        counts[c] = counts[c] + 1;
    }
    else
    {
        counts[c] = 1;
    }
}

foreach (var pair in counts)
{
    Console.WriteLine($"{pair.Key}: {pair.Value}번");
}

그 밖의 컬렉선

Stack<T> - 마지막에 넣은 것부터

Push 로 쌓고 Pop 으로 꺼냄. 나중에 넣은 것이 먼저 나옴.

csharp
// Stack 사용 예시
Stack<string> history = new Stack<string>();

history.Push("첫 화면");
history.Push("목록");
history.Push("상세");

Console.WriteLine($"현재: {history.Peek()}");   // 꺼내지 않고 보기만

Console.WriteLine($"뒤로: {history.Pop()}");
Console.WriteLine($"뒤로: {history.Pop()}");
Console.WriteLine($"남은 개수: {history.Count}");

Queue<T> - 먼저 넣은 것부터

Enqueue 로 줄 세우고 Dequeue 로 꺼냄. 먼저 넣은 것이 먼저 나옴.

csharp
// Queue 사용 예시
Queue<string> waiting = new Queue<string>();

waiting.Enqueue("1번 손님");
waiting.Enqueue("2번 손님");
waiting.Enqueue("3번 손님");

Console.WriteLine($"다음 차례: {waiting.Peek()}");

while (waiting.Count > 0)
{
    Console.WriteLine($"호출: {waiting.Dequeue()}");
}

HashSet<T> - 중복을 담지 않음

같은 값을 여러 번 넣어도 하나만 남음. 들어 있는지 확인하는 것이 빠름.

csharp
// HashSet 사용 예시
HashSet<int> numbers = new HashSet<int>();

Console.WriteLine(numbers.Add(1));
Console.WriteLine(numbers.Add(2));
Console.WriteLine(numbers.Add(1));      // 이미 있으므로 False

Console.WriteLine($"개수: {numbers.Count}");
Console.WriteLine($"2 있는가: {numbers.Contains(2)}");

배열에서 중복을 걷어낼 때 쓰면 짧음.

csharp
// 중복 제거 예시
int[] withDuplicates = { 3, 1, 4, 1, 5, 9, 2, 6, 5, 3 };

HashSet<int> unique = new HashSet<int>(withDuplicates);

Console.WriteLine($"원본: {withDuplicates.Length}개");
Console.WriteLine($"중복 제거: {unique.Count}개 -> {string.Join(", ", unique)}");

집합 연산도 제공함.

csharp
// 집합 연산 예시
HashSet<string> a = new HashSet<string> { "검", "방패", "물약" };
HashSet<string> b = new HashSet<string> { "물약", "활", "검" };

HashSet<string> both = new HashSet<string>(a);
both.IntersectWith(b);  // 교집합
Console.WriteLine($"둘 다: {string.Join(", ", both)}");     // 출력 결과 둘 다: 검, 물약

HashSet<string> all = new HashSet<string>(a);
all.UnionWith(b);       // 합집합
Console.WriteLine($"합치면: {string.Join(", ", all)}");     // 출력 결과 합치면: 검, 방패, 물약, 활

HashSet<string> onlyA = new HashSet<string>(a);
onlyA.ExceptWith(b);    // 차집합
Console.WriteLine($"a 에만: {string.Join(", ", onlyA)}");   // 출력 결과 a 에만: 방패

무엇을 쓸지

Mermaid
렌더링 중...
컬렉션쓰는 자리자리 번호 접근
List<T>순서대로 담고 자유롭게 꺼냄가능
Dictionary<TKey, TValue>키로 값을 찾음키로 접근
HashSet<T>중복 없이 담고 포함 여부를 봄불가
Stack<T>되돌리기, 되짚어 가기불가
Queue<T>대기열, 처리 순서불가

정렬

Sort의 기본 동작

List<T> 는 Sort 로 자기 자신을 정렬함. 별도의 배열을 만들지 않고 그 자리에서 순서를 바꿈.

csharp
// 기본 타입 정렬 예시
List<int> numbers = new List<int> { 5, 2, 9, 1, 7 };
numbers.Sort();
Console.WriteLine(string.Join(", ", numbers));

List<string> names = new List<string> { "박민수", "김철수", "이영희" };
names.Sort();
Console.WriteLine(string.Join(", ", names));

names.Reverse();
Console.WriteLine(string.Join(", ", names));

int 와 string 은 비교 기준이 이미 정해져 있으므로 바로 정렬됨. 직접 만든 클래스는 그렇지 않음. 무엇을 기준으로 앞뒤를 정할지 알려 준 적이 없기 때문임.

IComparable<T>로 기본 순서 정하기

IComparable<T> 는 .NET 에 이미 정의되어 있는 인터페이스로, 멤버가 하나뿐임. 돌려주는 값의 뜻은 다음과 같음.

반환값뜻
음수자기가 other보다 앞
0순서상 같음
양수자기가 other보다 뒤
클래스가 이것을 구현하면 Sort 가 그 기준을 씀.
csharp
// IComparable<T> 상속 및 적용 후 정렬 예시
List<Monster> monsters = new List<Monster>
{
    new Monster("고블린", 30),
    new Monster("드래곤", 100),
    new Monster("슬라임", 10),
    new Monster("오크", 50)
};

monsters.Sort();
foreach (Monster m in monsters)
{
    Console.WriteLine($"  {m}");
}

class Monster : IComparable<Monster>
{
    public string Name;
    public int Power;

    public Monster(string name, int power)
    {
        Name = name;
        Power = power;
    }

    // 전투력이 낮은 쪽이 앞
    public int CompareTo(Monster other)
    {
        if (other == null)
        {
            return 1;
        }
        return Power.CompareTo(other.Power);
    }

    public override string ToString() => $"{Name}(전투력 {Power})";
}

Power.CompareTo(other.Power) 처럼 이미 순서를 아는 타입에게 떠넘기는 것이 가장 간단한 구현임. 부호를 뒤집으면 내림차순이 됨.

기준을 여러 개 두기

앞 기준이 같을 때만 다음 기준을 봄.

csharp
// 기준이 같을 때 다른 기준을 통하여 앞과 뒤를 확인하는 예시
List<Student> students = new List<Student>
{
    new Student("김철수", 2, 85),
    new Student("이영희", 1, 92),
    new Student("박민수", 2, 92),
    new Student("최지우", 1, 85)
};

class Student : IComparable<Student>
{
    public string Name;
    public int Grade;
    public int Score;

    public Student(string name, int grade, int score)
    {
        Name = name;
        Grade = grade;
        Score = score;
    }

    public int CompareTo(Student other)
    {
        // 1순위: 학년 오름차순
        int byGrade = Grade.CompareTo(other.Grade);
        if (byGrade != 0)
        {
            return byGrade;
        }

        // 2순위: 점수 내림차순
        return other.Score.CompareTo(Score);
    }

    public override string ToString() => $"{Grade}학년 {Name} {Score}점";
}

그때그때 다른 기준으로 정렬하기

IComparable<T> 로 정한 것은 그 타입의 기본 순서임. 다른 기준이 필요하면 Sort 에 비교 방법을 람다식으로 넘김.

csharp
// 람다식을 통한 기준 변경 예시
List<Monster> monsters = new List<Monster>
{
    new Monster("고블린", 30),
    new Monster("블랙드래곤", 100),
    new Monster("오크", 50)
};

// 이름 가나다순
monsters.Sort((a, b) => a.Name.CompareTo(b.Name));
Console.WriteLine("이름순: " + string.Join(", ", monsters));        // 이름순: 고블린, 블랙드래곤, 오크

// 전투력 내림차순
monsters.Sort((a, b) => b.Power.CompareTo(a.Power));
Console.WriteLine("전투력순: " + string.Join(", ", monsters));      // 전투력순: 블랙드래곤, 오크, 고블린

// 이름 길이순
monsters.Sort((a, b) => a.Name.Length.CompareTo(b.Name.Length));
Console.WriteLine("길이순: " + string.Join(", ", monsters));        // 길이순: 오크, 고블린, 블랙드래곤

class Monster
{
    public string Name;
    public int Power;

    public Monster(string name, int power)
    {
        Name = name;
        Power = power;
    }

    public override string ToString() => Name;
}

같은 목록을 세 가지 기준으로 정렬했고, 클래스에는 CompareTo 가 없음. 이 방식은 IComparable<T> 를 구현하지 않은 클래스에도 쓸 수 있음. 어느 쪽을 쓸지는 다음과 같이 정함.

상황방법
그 타입에 "당연한 순서"가 있음IComparable<T>구현
상황마다 기준이 다름Sort에 람다식을 넘김

넣는 순간부터 정렬되어 있는 컬렉션

SortedDictionary<TKey, TValue> 는 키 순서로 정렬된 상태를 유지함. 넣을 때마다 제자리를 찾아 들어감.

csharp
// SortedDictionary 사용 예시
SortedDictionary<string, int> scores = new SortedDictionary<string, int>();

scores["박민수"] = 78;
scores["김철수"] = 85;
scores["이영희"] = 92;

// 넣은 순서와 무관하게 키 순서로 나옴
foreach (var pair in scores)
{
    Console.WriteLine($"{pair.Key}: {pair.Value}점");
}

SortedSet<T> 도 같은 식으로 동작함.

csharp
// SortedSet 사용 예시
SortedSet<int> numbers = new SortedSet<int> { 42, 7, 19, 7, 3 };

Console.WriteLine(string.Join(", ", numbers));
Console.WriteLine($"가장 작은 값: {numbers.Min}");
Console.WriteLine($"가장 큰 값: {numbers.Max}");

정렬 상태를 유지하는 대가로 넣고 빼는 것이 Dictionary 보다 느림. 항상 정렬된 채로 순회해야 할 때만 씀.