C#常用集合的使用

大多数集合都在System.Collections，System.Collections.Generic两个命名空间。其中System.Collections.Generic专门用于泛型集合。

针对特定类型的集合类型位于System.Collections.Specialized;命名空间；

线程安全的集合类位于System.Collections.Concurrent;命名空间。

下面是集合和列表实现的接口如下：

一、列表

[csharp] view plaincopy

  1. [Serializable]
  2. [DebuggerTypeProxy(typeof(Mscorlib_CollectionDebugView<>))]
  3. [DebuggerDisplay("Count = {Count}")]
  4. public class List<T> : IList<T>, ICollection<T>, IEnumerable<T>, IList, ICollection, IEnumerable

从这个可以看出，泛型集合List<T>实现了这么多接口，具体接口的信息可以通过工具查看。

[csharp] view plaincopy

  1. using System;
  2. using System.Collections.Generic;
  3. namespace ConsoleApplication1
  4. {
  5. public class Program
  6. {
  7. static void Main(string[] args)
  8. {
  9. List<String> list = new List<string>();
  10. list.Add("张三");
  11. list.Add("李四");
  12. list.Add("王五");
  13. list.Add("田六");
  14. list.Add("赵七");
  15. for (int i = 0; i < list.Count; i++)
  16. {
  17. Console.WriteLine("for循环：" + i.ToString() + "=" + list[i]);
  18. }
  19. list.RemoveAt(0);
  20. foreach (String item in list)
  21. {
  22. Console.WriteLine("foreach迭代：" + item);
  23. }
  24. list.AddRange(new String[] { "Hello1", "Hello2", "Hello3" });
  25. list.ForEach(Print);
  26. Console.Read();
  27. }
  28. private static void Print(String item)
  29. {
  30. Console.WriteLine("ForEach：" + item);
  31. }
  32. }
  33. }

二、队列

队列先进先出，一头进一头出，用Queue<T>实现

[csharp] view plaincopy

  1. [Serializable]
  2. [DebuggerTypeProxy(typeof(System_QueueDebugView<>))]
  3. [ComVisible(false)]
  4. [DebuggerDisplay("Count = {Count}")]
  5. public class Queue<T> : IEnumerable<T>, ICollection, IEnumerable

可以看出队列实现了集合的接口，迭代的接口

[csharp] view plaincopy

  1. using System;
  2. using System.Collections.Generic;
  3. namespace ConsoleApplication1
  4. {
  5. public class Program
  6. {
  7. static void Main(string[] args)
  8. {
  9. Queue<String> queue = new Queue<string>();
  10. //进队
  11. queue.Enqueue("张三");
  12. queue.Enqueue("李四");
  13. queue.Enqueue("王五");
  14. queue.Enqueue("田六");
  15. queue.Enqueue("赵七");
  16. foreach (String item in queue)
  17. {
  18. Console.WriteLine("foreach迭代：" + item);
  19. }
  20. //出队
  21. while (queue.Count > 0)
  22. {
  23. Console.WriteLine("出队：" + queue.Dequeue());
  24. }
  25. Console.Read();
  26. }
  27. }
  28. }

三、栈

栈：从同一边先进后出，用Stack<T>实现

[csharp] view plaincopy

  1. [DebuggerDisplay("Count = {Count}")]
  2. [DebuggerTypeProxy(typeof(System_StackDebugView<>))]
  3. [ComVisible(false)]
  4. public class Stack<T> : IEnumerable<T>, ICollection, IEnumerable

栈也是实现了集合接口与迭代接口的

[csharp] view plaincopy

  1. using System;
  2. using System.Collections.Generic;
  3. namespace ConsoleApplication1
  4. {
  5. public class Program
  6. {
  7. static void Main(string[] args)
  8. {
  9. Stack<String> stack = new Stack<string>();
  10. //进栈
  11. stack.Push("张三");
  12. stack.Push("李四");
  13. stack.Push("王五");
  14. stack.Push("田六");
  15. stack.Push("赵七");
  16. foreach (String item in stack)
  17. {
  18. Console.WriteLine("foreach迭代：" + item);
  19. }
  20. //出栈
  21. while (stack.Count > 0)
  22. {
  23. Console.WriteLine("出栈：" + stack.Pop());
  24. }
  25. Console.Read();
  26. }
  27. }
  28. }

四、链表

LinkedList是一个双向链表，链表有个有点，就是在链表中间插入、删除元素很快，但是查找中间与末尾的元素很慢，需要一个节点一个节点的去找。

[csharp] view plaincopy

  1. [Serializable]
  2. [DebuggerTypeProxy(typeof(System_CollectionDebugView<>))]
  3. [DebuggerDisplay("Count = {Count}")]
  4. [ComVisible(false)]
  5. public class LinkedList<T> : ICollection<T>, IEnumerable<T>, ICollection, IEnumerable, ISerializable, IDeserializationCallback

由此可见链表也是有集合的特性的，可以迭代，同时还有链表的特性

[csharp] view plaincopy

  1. using System;
  2. using System.Collections.Generic;
  3. namespace ConsoleApplication1
  4. {
  5. public class Program
  6. {
  7. static void Main(string[] args)
  8. {
  9. LinkedList<String> lList = new LinkedList<string>();
  10. LinkedListNode<String> node = new LinkedListNode<string>("root");
  11. lList.AddFirst(node);
  12. node = lList.AddAfter(node, "张三");
  13. node = lList.AddAfter(node, "李四");
  14. node = lList.AddAfter(node, "王五");
  15. node = lList.AddAfter(node, "田六");
  16. node = lList.AddAfter(node, "赵七");
  17. foreach (String item in lList)
  18. {
  19. Console.WriteLine("foreach迭代：" + item);
  20. }
  21. node = lList.First;
  22. Console.WriteLine("第一个元素：" + node.Value);
  23. node = lList.Last;
  24. Console.WriteLine("最后一个元素：" + node.Value);
  25. Console.Read();
  26. }
  27. }
  28. }

五、有序列表

SortedList采用键-值对存储，键不能重复，并且会根据key进行排序

[csharp] view plaincopy

  1. [Serializable]
  2. [DebuggerTypeProxy(typeof(System_DictionaryDebugView<,>))]
  3. [DebuggerDisplay("Count = {Count}")]
  4. [ComVisible(false)]
  5. public class SortedList<TKey, TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IDictionary, ICollection, IEnumerable

可以看出SortedList不仅具有字典的特性，还有集合，迭代的功能

[csharp] view plaincopy

  1. using System;
  2. using System.Collections.Generic;
  3. namespace ConsoleApplication1
  4. {
  5. public class Program
  6. {
  7. static void Main(string[] args)
  8. {
  9. //Key必须唯一，如果不唯一可以考虑Lookup<TKey,TElement>
  10. SortedList<int, String> sList = new SortedList<int, string>();
  11. sList.Add(100, "张三");
  12. sList.Add(21, "李四");
  13. sList.Add(13, "王五");
  14. sList.Add(44, "田六");
  15. sList.Add(35, "赵七");
  16. foreach (KeyValuePair<int, String> item in sList)
  17. {
  18. Console.WriteLine("key=" + item.Key.ToString() + "；value=" + item.Value);
  19. }
  20. Console.Read();
  21. }
  22. }
  23. }

六、字典

字典是很复杂的数据结构，允许通过key来查找值，字典可以自由添加、删除元素，没有集合由于移动元素导致的开销。

[csharp] view plaincopy

  1. [Serializable]
  2. [DebuggerTypeProxy(typeof(Mscorlib_DictionaryDebugView<,>))]
  3. [DebuggerDisplay("Count = {Count}")]
  4. [ComVisible(false)]
  5. public class Dictionary<TKey, TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IDictionary, ICollection, IEnumerable, ISerializable, IDeserializationCallback

可以看出字典也具有集合的特性，可以迭代

[csharp] view plaincopy

  1. using System;
  2. using System.Collections.Generic;
  3. namespace ConsoleApplication1
  4. {
  5. public class Program
  6. {
  7. static void Main(string[] args)
  8. {
  9. //Key必须唯一
  10. Dictionary<int, String> dict = new Dictionary<int, string>();
  11. dict.Add(11, "张三");
  12. dict.Add(1, "李四");
  13. dict.Add(2, "王五");
  14. dict.Add(16, "田六");
  15. dict.Add(12, "赵七");
  16. foreach (KeyValuePair<int, String> item in dict)
  17. {
  18. Console.WriteLine("key=" + item.Key.ToString() + "；value=" + item.Value);
  19. }
  20. Console.Read();
  21. }
  22. }
  23. }

说到字典，顺便谈一下有序字典，与有序列表对应；SortedDictionary，SortedList，SortedSet

会根据Key进行排序

[csharp] view plaincopy

  1. using System;
  2. using System.Collections.Generic;
  3. namespace ConsoleApplication1
  4. {
  5. public class Program
  6. {
  7. static void Main(string[] args)
  8. {
  9. //Key必须唯一
  10. SortedDictionary<int, String> dict = new SortedDictionary<int, string>();
  11. dict.Add(11, "张三");
  12. dict.Add(1, "李四");
  13. dict.Add(2, "王五");
  14. dict.Add(16, "田六");
  15. dict.Add(12, "赵七");
  16. foreach (KeyValuePair<int, String> item in dict)
  17. {
  18. Console.WriteLine("key=" + item.Key.ToString() + "；value=" + item.Value);
  19. }
  20. Console.Read();
  21. }
  22. }
  23. }

七、集

集(Set)：包含不重复元素，常用HashSet，SortedSet

[csharp] view plaincopy

  1. [Serializable]
  2. [DebuggerDisplay("Count = {Count}")]
  3. [DebuggerTypeProxy(typeof(HashSetDebugView<>))]
  4. public class HashSet<T> : ISerializable, IDeserializationCallback, ISet<T>, ICollection<T>, IEnumerable<T>, IEnumerable

[csharp] view plaincopy

  1. [Serializable]
  2. [DebuggerTypeProxy(typeof(SortedSetDebugView<>))]
  3. [DebuggerDisplay("Count = {Count}")]
  4. public class SortedSet<T> : ISet<T>, ICollection<T>, IEnumerable<T>, ICollection, IEnumerable, ISerializable, IDeserializationCallback

[csharp] view plaincopy

  1. using System;
  2. using System.Collections.Generic;
  3. namespace ConsoleApplication1
  4. {
  5. public class Program
  6. {
  7. static void Main(string[] args)
  8. {
  9. HashSet<String> hSet = new HashSet<string>();
  10. hSet.Add("张三");
  11. hSet.Add("李四");
  12. hSet.Add("王五");
  13. hSet.Add("田六");
  14. hSet.Add("赵七");
  15. foreach (String item in hSet)
  16. {
  17. Console.WriteLine("foreach迭代：" + item);
  18. }
  19. Console.Read();
  20. }
  21. }
  22. }

[csharp] view plaincopy

  1. using System;
  2. using System.Collections.Generic;
  3. namespace ConsoleApplication1
  4. {
  5. public class Program
  6. {
  7. static void Main(string[] args)
  8. {
  9. SortedSet<String> hSet = new SortedSet<string>();
  10. hSet.Add("张三");
  11. hSet.Add("李四");
  12. hSet.Add("王五");
  13. hSet.Add("田六");
  14. hSet.Add("赵七");
  15. foreach (String item in hSet)
  16. {
  17. Console.WriteLine("foreach迭代：" + item);
  18. }
  19. Console.Read();
  20. }
  21. }
  22. }

性能比较：

---------------------------------------------------

时间： 2024-10-27 00:28:11

C#常用集合的使用的相关文章

比较Java中几个常用集合添加元素的效率

初始化需要进行比较的集合,统一增加10万个元素,获取整个过程的执行时间. 1.List集合增加元素 1 private static void testList() { 2 3 List<Integer> list = new ArrayList<Integer>(); 4 5 long startTime = System.currentTimeMillis(); // 获取开始时间 6 for (int i = 0; i < 100000; i++) { 7 8 list

.NET基础 （09）常用集合和泛型

常用集合和泛型1 int[]是引用类型还是值类型2 数组之间如何进行转换3 解释泛型的基本原理4 什么是泛型的主要约束和次要约束 常用集合和泛型1 int[]是引用类型还是值类型 数组类型是一族类型,它们都继承自System.Array,而System.Array又继承自System.Object.所有数组的类型都是引用类型. 引用类型的数组和值类型的数组的内存分配: 2 数组之间如何进行转换 数组类型在符合条件的情况下可以进行隐式地转换,条件包括:数组维数必须相同:目标项目类型和源项目类型必须

【总结】Java常用集合接口与集合类

目录 常见集合接口概述 Collection<E> Map<K,V> Collection接口 Map接口 补充内容 ? 常见集合接口概述 Java中包含许多集合接口.其中比较常见的主要是Collection接口和Map接口: 1.1 Collection<E> 由单元素组成的集合.其比较常见的直接子接口是List.Set和Queue接口. ? ? ? ? 表1.1 Collection<e>接口常用方法 编号 方法原型 解释 备注 1 boolean?ad

JAVA集合框架中的常用集合及其特点、适用场景、实现原理简介

JJDK提供了大量优秀的集合实现供开发者使用,合格的程序员必须要能够通过功能场景和性能需求选用最合适的集合,这就要求开发者必须熟悉Java的常用集合类.本文将就Java Collections Framework中常用的集合及其特点.适用场景.实现原理进行介绍,供学习者参考.当然,要真正深入理解Java的集合实现,还是要推荐去阅读JDK的源码. Java提供的众多集合类由两大接口衍生而来:Collection接口和Map接口 Collection接口 Collection接口定义了一个包含一批对

C#常用集合

数组的缺点:长度固定.因此引入集合的使用. 注:泛型集合更安全,性能更高. 常用集合 对应泛型 ①动态数组ArrayList    List<T> 常用方法属性:Add  Clear  Contains  IndexOf  Insert  Remove  Sort ②哈希表Hashtable   Dictionary<TKey,TValue> 常用方法属性:Add  Clear  ContainsKey  ContainsValue  Remove ③排序列表SortedList 

c++STL之常用集合算法

set_intersection:求两个容器的交集 set_union:求两个集合的并集 set_difference:求两个集合的差集 1.set_intersection #include<iostream> using namespace std; #include <vector> #include <algorithm> //常用集合算法 set_intersection void myPrint(int val) { cout << val &l

JAVA常用集合框架用法详解基础篇一之Colletion接口

首先,在学习集合之前我们能够使用的可以存储多个元素的容器就是数组. 下面举几个例子主要是引出集合类的: 1.8,4,5,6,7,55,7,8  像这样的类型相同的可以使用数组来存储,本例可以用int[] arr来存储. 2."zhnagsan",true,68 像这样的可以使用StringBuilder或者StringBuffer来存储,但最终需要使用.toString()的方法转换成字符串才可以使用.即 变为:"zhnagsantrue68". 3."李

Java 常用集合操作

List接口是Collection的子接口,用于定义线性表结构,其中ArrayList可以理解为一个动态数组,而LinkedList可以理解为一个链表 常用操作: 插入和删除操作: void add(int index,E element): 将给定的元素插入到指定位置,原位置及后续元素都顺序向后移动. E remove(int index): 删除给定位置的元素,并将被删除的元素返回. get和set方法: List除了继承Collection定义的方法外,还根据其线性表的数据结构定义了一系列

【Python 学习笔记 2】Python中常用集合类型：List,Tuple,Set,Dict使用简介

在使用Python编程中,我们最常用的几种集合类型是:List,Tuple,Set,Dict:下面简单聊聊这几种集合类型: List 列表:相当于一个数组,不过list的长度是自动变化的而且列表元素自由的,不必每个元素都是同一种类型.它的简洁的定义方式是a=[].是一种有序组合,可以删除和添加其中的元素: List的基本操作如下: ##生成一个list,并赋值给list_ex >>> list_ex=[1,3,4,"list","Tuple",&q