C# 集合

最后修改于 2023 年 7 月 5 日

在本文中，我们将使用 C# 集合。集合是用于数据存储和检索的专用类。

C# 中有三种不同的集合类型

• 标准
• 泛型
• 并发

标准集合位于 System.Collections 下。它们不将元素存储为特定类型的对象，而是存储为 Object 类型的对象。标准集合包括 ArrayList、Hashtable、Queue 和 Stack。

泛型集合位于 System.Collections.Generic 下。泛型集合更加灵活，是处理数据的首选方式。泛型增强了代码重用性、类型安全性和性能。泛型集合包括 Dictionary<T, T>、List<T>、Queue<T>、SortedList<T> 和 Stack<T>。

并发集合包括 BlockingCollection<T>、ConcurrentDictionary<T, T>、ConcurrentQueue<T> 和 ConcurrentStack<T>。

C# 列表

List 是可以通过索引访问的强类型对象列表。它可以在 System.Collections.Generic 命名空间下找到。该命名空间自动包含在隐式 using 中。

var langs = new List<string>();

langs.Add("Java");
langs.Add("C#");
langs.Add("C");
langs.Add("C++");
langs.Add("Ruby");
langs.Add("Javascript");

Console.WriteLine(langs.Contains("C#"));

Console.WriteLine(langs[1]);
Console.WriteLine(langs[2]);

langs.Remove("C#");
langs.Remove("C");

Console.WriteLine(langs.Contains("C#"));

langs.Insert(4, "Haskell");

langs.Sort();

foreach (string lang in langs)
{
    Console.WriteLine(lang);
}

在前面的示例中，我们使用了 List 集合。

using System.Collections.Generic;

List 集合位于 System.Collections.Generic 命名空间中。

var langs = new List<string>();

创建了一个泛型动态数组。我们指定使用 <> 字符内的类型来处理字符串。

langs.Add("Java");
langs.Add("C#");
langs.Add("C");
...

我们使用 Add 方法将元素添加到 List 中。

Console.WriteLine(langs.Contains("C#"));

我们使用 Contains 方法检查 List 是否包含特定的字符串。

Console.WriteLine(langs[1]);
Console.WriteLine(langs[2]);

我们使用索引表示法访问 List 的第二个和第三个元素。

langs.Remove("C#");
langs.Remove("C");

我们从 List 中删除两个字符串。

langs.Insert(4, "Haskell");

我们在特定位置插入一个字符串。

langs.Sort();

我们使用 Sort 方法对元素进行排序。

$ dotnet run
True
C#
C
False
C++
Haskell
Java
Javascript
Ruby

C# ArrayList

ArrayList 是来自标准 System.Collections 命名空间的集合。它是一个动态数组。它提供了对其元素的随机访问。ArrayList 会随着数据的添加自动扩展。与数组不同，ArrayList 可以保存多种数据类型的数据。ArrayList 中的元素通过整数索引访问。索引从零开始。元素的索引以及在 ArrayList 末尾的插入和删除都需要花费恒定的时间。在动态数组中间插入或删除元素的成本更高。它需要线性时间。

using System.Collections;

var data = new ArrayList();

data.Add("Visual Basic");
data.Add(344);
data.Add(55);
data.Add(new Empty());
data.Remove(55);

foreach (object el in data)
{
    Console.WriteLine(el);
}

class Empty {}

在上面的例子中，我们创建了一个 ArrayList 集合。我们向其中添加了一些元素。 它们具有各种数据类型：字符串、整数和类对象。

using System.Collections;

为了使用 ArrayList 集合，我们需要使用 System.Collections 命名空间。

var data = new ArrayList();

创建了一个 ArrayList 集合。

data.Add("Visual Basic");
data.Add(344);
data.Add(55);
data.Add(new Empty());
data.Remove(55);

我们使用 Add 方法将四个元素添加到数组中。

data.Remove(55);

我们使用 Remove 方法删除一个元素。

foreach(object el in data)
{
    Console.WriteLine(el);
}

我们迭代数组并将它的元素打印到控制台。

$ dotnet run
Visual Basic
344
Empty

C# 集合初始值设定项

集合初始值设定项允许在对象创建期间在 {} 括号内指定集合的元素。

var vals = new List<int>() { 1, 2, 3, 4, 5, 6, 7 };

int sum = vals.Sum();
Console.WriteLine(sum);

该示例创建一个列表并打印其总和。列表的元素在集合初始值设定项中指定。

$ dotnet run
28

C# SortedList

SortedList<T, T> 表示键/值对的排序集合。

var sorted = new SortedList<string, int>();

sorted.Add("coins", 3);
sorted.Add("books", 41);
sorted.Add("spoons", 5);

if (sorted.ContainsKey("books"))
{
    Console.WriteLine("There are books in the list");
}

foreach (var pair in sorted)
{
    Console.WriteLine(pair);
}

该示例使用排序列表来组织项目。

var sorted = new SortedList<string, int>();

排序列表具有字符串键和整数值。

if (sorted.ContainsKey("books"))
{
    Console.WriteLine("There are books in the list");
}

使用 ContainsKey 我们检查集合中是否有书籍。

foreach (var pair in sorted)
{
    Console.WriteLine(pair);
}

使用 foreach 循环，我们遍历集合并打印它的对。

$ dotnet run
There are books in the list
[books, 41]
[coins, 3]
[spoons, 5]

C# LinkedList

LinkedList 是 C# 中的通用双向链表。 LinkedList 仅允许顺序访问。 LinkedList 允许恒定时间的插入或删除，但仅允许元素的顺序访问。 因为链表需要额外的存储空间来存储引用，所以对于小型数据项（例如字符）列表来说，它们是不切实际的。

与动态数组不同，可以将任意数量的项目添加到链表中（当然，受内存限制），而无需重新分配，这是一项昂贵的操作。

var nums = new LinkedList<int>();

nums.AddLast(23);
nums.AddLast(34);
nums.AddLast(33);
nums.AddLast(11);
nums.AddLast(6);
nums.AddFirst(9);
nums.AddFirst(7);

LinkedListNode<int> node = nums.Find(6);
nums.AddBefore(node, 5);

foreach (int num in nums)
{
    Console.WriteLine(num);
}

这是一个带有某些方法的 LinkedList 示例。

var nums = new LinkedList<int>();

这是一个整数 LinkedList。

nums.AddLast(23);
...
nums.AddFirst(7);

我们使用 AddLast 和 AddFirst 方法填充链表。

LinkedListNode<int> node = nums.Find(6);
nums.AddBefore(node, 5);

一个 LinkedList 由节点组成。 我们找到一个特定的节点并在其前面添加一个元素。

foreach(int num in nums)
{
    Console.WriteLine(num);
}

我们将所有元素打印到控制台。

$ dotnet run
7
9
23
34
33
11
5
6

C# 字典

dictionary，也称为关联数组，是唯一键的集合和值的集合，其中每个键都与一个值关联。检索和添加值非常快。字典占用更多内存，因为每个值都有一个键。

var domains = new Dictionary<string, string>();

domains.Add("de", "Germany");
domains.Add("sk", "Slovakia");
domains.Add("us", "United States");
domains.Add("ru", "Russia");
domains.Add("hu", "Hungary");
domains.Add("pl", "Poland");

Console.WriteLine(domains["sk"]);
Console.WriteLine(domains["de"]);

Console.WriteLine("Dictionary has {0} items", domains.Count);

Console.WriteLine("Keys of the dictionary:");

var keys = new List<string>(domains.Keys);

foreach (string key in keys)
{
    Console.WriteLine("{0}", key);
}

Console.WriteLine("Values of the dictionary:");

var vals = new List<string>(domains.Values);

foreach (string val in vals)
{
    Console.WriteLine("{0}", val);
}

Console.WriteLine("Keys and values of the dictionary:");

foreach (KeyValuePair<string, string> kvp in domains)
{
    Console.WriteLine("Key = {0}, Value = {1}", kvp.Key, kvp.Value);
}

我们有一个字典，其中将域名映射到它们的国家/地区名称。

var domains = new Dictionary<string, string>();

我们创建一个具有字符串键和值的字典。

domains.Add("de", "Germany");
domains.Add("sk", "Slovakia");
domains.Add("us", "United States");
...

我们向字典添加一些数据。第一个字符串是键。第二个是值。

Console.WriteLine(domains["sk"]);
Console.WriteLine(domains["de"]);

在这里，我们通过它们的键检索两个值。

Console.WriteLine("Dictionary has {0} items", domains.Count);

我们通过引用 Count 属性来打印项目数。

var keys = new List<string>(domains.Keys);

foreach(string key in keys)
{
    Console.WriteLine("{0}", key);
}

这些行从字典中检索所有键。

var vals = new List<string>(domains.Values);

foreach(string val in vals)
{
    Console.WriteLine("{0}", val);
}

这些行从字典中检索所有值。

foreach(KeyValuePair<string, string> kvp in domains)
{
    Console.WriteLine("Key = {0}, Value = {1}", kvp.Key, kvp.Value);
}

最后，我们打印字典的键和值。

$ dotnet run
Slovakia
Germany
Dictionary has 6 items
Keys of the dictionary:
de
sk
us
ru
hu
pl
Values of the dictionary:
Germany
Slovakia
United States
Russia
Hungary
Poland
Keys and values of the dictionary:
Key = de, Value = Germany
Key = sk, Value = Slovakia
Key = us, Value = United States
Key = ru, Value = Russia
Key = hu, Value = Hungary
Key = pl, Value = Poland

C# 队列

queue 是一种先进先出 (FIFO) 数据结构。 添加到队列的第一个元素将是第一个被删除的元素。 队列可用于按出现顺序处理消息或按顾客到达顺序为顾客服务。 第一个来的顾客应该首先得到服务。

var msgs = new Queue<string>();

msgs.Enqueue("Message 1");
msgs.Enqueue("Message 2");
msgs.Enqueue("Message 3");
msgs.Enqueue("Message 4");
msgs.Enqueue("Message 5");

Console.WriteLine(msgs.Dequeue());
Console.WriteLine(msgs.Peek());
Console.WriteLine(msgs.Peek());

Console.WriteLine();

foreach (string msg in msgs)
{
    Console.WriteLine(msg);
}

在我们的示例中，我们有一个包含消息的队列。

var msgs = new Queue<string>();

创建了一个字符串队列。

msgs.Enqueue("Message 1");
msgs.Enqueue("Message 2");
...

Enqueue 将消息添加到队列的末尾。

Console.WriteLine(msgs.Dequeue());

Dequeue 方法删除并返回队列开头的项目。

Console.WriteLine(msgs.Peek());

Peek 方法从队列中返回下一个项目，但不会将其从集合中删除。

$ dotnet run
Message 1
Message 2
Message 2

Message 2
Message 3
Message 4
Message 5

Dequeue 方法从集合中删除“消息 1”。 Peek 方法不会。“消息 2”保留在集合中。

C# 堆栈

堆栈 是一种后进先出 (LIFO) 数据结构。 添加到队列的最后一个元素将是第一个被删除的元素。 C 语言使用堆栈来存储函数中的本地数据。 堆栈也用于实现计算器。

var myStack = new Stack<int>();

myStack.Push(1);
myStack.Push(4);
myStack.Push(3);
myStack.Push(6);
myStack.Push(4);

Console.WriteLine(myStack.Pop());
Console.WriteLine(myStack.Peek());
Console.WriteLine(myStack.Peek());

Console.WriteLine();

foreach (int item in myStack)
{
    Console.WriteLine(item);
}

我们上面有一个简单的堆栈示例。

var myStack = new Stack<int>();

创建了一个 Stack 数据结构。

myStack.Push(1);
myStack.Push(4);
...

Push 方法将项目添加到堆栈的顶部。

Console.WriteLine(stc.Pop());

Pop 方法删除并返回堆栈顶部的项目。

Console.WriteLine(myStack.Peek());

Peek 方法从堆栈顶部返回项目。 它不会删除它。

$ dotnet run
4
6
6

6
3
4
1

来源

集合

在本文中，我们使用了 C# 中的集合。

作者

我叫 Jan Bodnar，是一名充满激情的程序员，拥有丰富的编程经验。 自 2007 年以来，我一直在撰写编程文章。 迄今为止，我已经撰写了 1,400 多篇文章和 8 本电子书。 我拥有超过十年的编程教学经验。

列出所有 C# 教程。