제네릭과 컬렉션
20261029 제네릭과 컬렉션
개요
배열은 만들 때 크기를 정하고 나면 바꿀 수 없음. 요소를 하나 더 넣으려면 더 큰 배열을 새로 만들어 전부 옮겨야 함.
.NET 은 이런 일을 대신 해 주는 컬렉션(collection) 을 제공함. 그런데 컬렉션을 이해하려면 그 이름에 붙어 있는 꺾쇠 표기를 먼저 알아야 함.
List<string> 의 <string> 은 “이 목록에는 string 만 담는다”는 뜻임. 이 표기를 제네릭(generic) 이라고 함.
제네릭
제네릭은 일반화와 동의어다
타입이 정해지지 않은 그릇이 필요할 때
정수를 담아 두었다가 꺼내는 상자를 만든다고 하면 int를 받는 클래스(예를 들어 IntBox클래스)를 만들어야함.
문자열도 담고 싶으면 StringBox 를 또 만들어야 함. 담을 타입마다 클래스를 만드는 것은 끝이 없음.
제네릭이 없던 시절에는 모든 타입의 조상인 object에 담아 이 문제를 피했음. 하지만 이 경우 담기는 하는데, 꺼낼 때 문제가 생김. 되돌리는 것 자체도 번거롭지만, 진짜 문제는 엉뚱한 것이 들어가 있어도 컴파일러가 막지 못한다는 점임. 잘못을 컴파일 시점이 아니라 실행 시점에 알게 됨. 프로그램이 커질수록 이런 실수는 찾기 어려워짐.
박싱과 언박싱
object 에 담을 때는 성능 문제도 함께 따라옴.
int·double·bool 같은 값 타입은 값을 그 자리에 직접 갖고 있음. 반면 object 는 참조 타입이므로 값이 있는 곳을 가리키기만 함. 값 타입을 object 에 넣으려면 그 값을 힙에 새로 만들어 감싸야 하는데, 이것을 박싱(boxing) 이라고 함. 꺼내면서 되돌리는 것은 언박싱(unboxing)임. 값을 담고 꺼낼 때마다 박싱과 언박싱이 일어나므로, 많은 값을 다루면 비용이 쌓임. 박싱과 언박싱은 구조체와 연산자 오버로딩 정리할 때 적어뒀으니 여기까지만 적음.
타입을 매개변수로 받기
제네릭은 클래스를 만들 때 타입 자리를 비워 두고, 쓰는 쪽에서 채우게 하는 기능임.
// 제네릭을 통해 사용할 때 타입을 정하는 예시
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 로 시작하는 이름을 붙여 구분함.
// 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로 저장, 반환하는 이 경로에서는 불필요 |
제네릭 메서드
클래스 전체가 아니라 메서드 하나만
타입만 다르고 하는 일이 같은 메서드가 여럿 생기는 경우가 있음.
// 타입만 다르고 하는 일이 같은 메서드 예시
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 를 알아내기 때문임. 이것을 타입 추론 이라고 함.
명시적으로 적을 수도 있음. 다음 두 표기는 같은 뜻임. 인수만 보고는 알 수 없는 경우에는 명시해야 함.
// 같은 뜻을 가진 표기
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 자리에 무엇이든 올 수 있다는 것은 무엇이든 온다고 가정하고 코드를 써야 한다는 뜻이기도 함. 두 값 중 큰 것을 돌려주려 해도 비교할 수 없음.
// 타입 제약이 필요할 수도 있는 상황 예시
// 예를 들어 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 등이 모두 구현하고 있음.
// IComparable 타입 제약 사용 예시
static T GetMax<T>(T a, T b) where T : IComparable<T>
{
return a.CompareTo(b) > 0 ? a : b;
}
제약을 걸었으므로 CompareTo 를 쓸 수 있음. 제약이 없으면 그 메서드가 있다고 볼 근거가 없어 컴파일되지 않음. 제약을 만족하지 않는 타입을 넘기면 그 자리에서 막힘(컴파일되지 않음).
값 타입 제약과 참조 타입 제약
// 값 타입 제약에 각각 값타입과 참조타입을 넣을 경우 예시
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() 제약이 필요함.
// 생성자 제약 예시
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() 는 맨 뒤에 와야 함.
// 여러개의 제약을 거는 예시
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 를 자리마다 따로 적음. 하나에 몰아 쓰지 않음.
// 타입별 제약 예시
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) 임.
// 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 |
bool | false |
char | \0 |
참조 타입(string, 클래스) | null |
| 구조체 | 모든 필드가 각자의 기본 값인 상태 |
new T[크기] 로 만든 배열의 칸도 모두 이 값으로 채워져 있음.
// 배열에 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 만 적어도 됨.
제네릭 클래스를 상속하기
제네릭 클래스도 상속할 수 있음. 부모의 타입 자리를 어떻게 다루느냐에 따라 모양이 갈림. 첫째는 타입 자리를 그대로 물려받는 것임. 자식도 제네릭 클래스가 됨.
// 제네릭 클래스 상속 예시
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 타입으로 보임.
타입을 정해 놓고 상속하기
둘째는 부모의 타입 자리를 자식이 채워 버리는 것임. 자식은 더 이상 제네릭이 아님.
// 자식 클래스에서 타입을 확정시켜놓는 예시
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 가 무엇일지 몰라 못 하던 일임.
타입 자리를 하나 더 늘리기
셋째는 부모의 타입 자리를 물려받으면서 자식이 자리를 더 붙이는 것임.
// 자식 클래스에서 추가로 제네릭을 더하는 예시
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 멤버를 두면 그 값도 타입마다 따로 생김.
// 타입별 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> |
|---|---|---|
| 개수 | Length | Count |
| 크기 | 만들 때 고정 | 넣는 대로 늘어남 |
| 요소 접근 | arr[0] | list[0] |
| 추가 | 불가 | Add |
만드는 여러 표기
// 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)}");
넣고 빼기
// 요소를 넣고 빼는 예시
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}개");
찾기
// 검색
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> 는 델리게이트를 받는 메서드를 여럿 갖고 있음. 조건을 람다식으로 넘기면 반복문을 직접 쓰지 않아도 됨.
// 반복문을 쓰지 않고 람다식으로 적는 예시
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 문을 씀.
// 뒤에서부터 도는 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)을 짝지어 저장하고, 키로 값을 찾음.
// 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 를 씀.
// 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 쪽이 나음.
고치고 지우기
// 수정 및 삭제 예시
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")}");
키만, 값만 꺼내기
// 키나 값만 꺼내는 예시
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}");
개수 세기에 쓰기
문자별 등장 횟수처럼 “무엇이 몇 번”을 세는 일에 잘 맞음.
// 개수 셀때 사용하는법 예시
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 으로 꺼냄. 나중에 넣은 것이 먼저 나옴.
// 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 로 꺼냄. 먼저 넣은 것이 먼저 나옴.
// 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> - 중복을 담지 않음
같은 값을 여러 번 넣어도 하나만 남음. 들어 있는지 확인하는 것이 빠름.
// 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)}");
배열에서 중복을 걷어낼 때 쓰면 짧음.
// 중복 제거 예시
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)}");
집합 연산도 제공함.
// 집합 연산 예시
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 에만: 방패
무엇을 쓸지
| 컬렉션 | 쓰는 자리 | 자리 번호 접근 |
|---|---|---|
List<T> | 순서대로 담고 자유롭게 꺼냄 | 가능 |
Dictionary<TKey, TValue> | 키로 값을 찾음 | 키로 접근 |
HashSet<T> | 중복 없이 담고 포함 여부를 봄 | 불가 |
Stack<T> | 되돌리기, 되짚어 가기 | 불가 |
Queue<T> | 대기열, 처리 순서 | 불가 |
정렬
Sort의 기본 동작
List<T> 는 Sort 로 자기 자신을 정렬함. 별도의 배열을 만들지 않고 그 자리에서 순서를 바꿈.
// 기본 타입 정렬 예시
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 가 그 기준을 씀. |
// 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) 처럼 이미 순서를 아는 타입에게 떠넘기는 것이 가장 간단한 구현임. 부호를 뒤집으면 내림차순이 됨.
기준을 여러 개 두기
앞 기준이 같을 때만 다음 기준을 봄.
// 기준이 같을 때 다른 기준을 통하여 앞과 뒤를 확인하는 예시
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 에 비교 방법을 람다식으로 넘김.
// 람다식을 통한 기준 변경 예시
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> 는 키 순서로 정렬된 상태를 유지함. 넣을 때마다 제자리를 찾아 들어감.
// 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> 도 같은 식으로 동작함.
// 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 보다 느림. 항상 정렬된 채로 순회해야 할 때만 씀.



