1.集合接口与集合类型
(1)集合的命名空间
大多数集合类都可以在 System.Collections 和 System.Collections.Generic 名称空间中找到。
泛型集合位于 System.Collections.Generic 名称空间中；
专用于特定类型的集合类位于 System.Collections.Specialized 名称空间中；
线程安全的集合位于 System.Collections.Concurrent 名称空间中。
(2)集合接口介绍
1、 IEnumerable 与 IEnumerator 接口
其实IEnumerable接口是非常的简单，只包含一个抽象的方法 GetEnumerator ()，它返回一个可用于循环访问集合的IEnumerator对象。
public interface IEnumerable
{
IEnumerator GetEnumerator();
}
IEnumerator对象有什么呢？
它是一个真正的集合访问器，没有它，就不能使用foreach语句遍历集合或数组，因为只有IEnumerator对象才能访问集合中的项。
IEnumerator接口定义了：一个Current属性用来获取当前集合中的项；MoveNext方法将游标的内部位置向前移动；Reset方法将枚举数设置为其初始位置，该位置位于集合中第一个元素之前。
public interface IEnumerator
{
object Current { get; }
bool MoveNext();
void Reset();
}
一个collection要支持foreach进行遍历，就必须实现 IEnumerable ,并以某种方式返回迭代器对象: IEnumerator 。
2、集合和列表实现的接口表
接口
说明
IEnumerable<T>
如果foreach语句用于集合，就需要此接口。
ICollection<T>
此集合定义了Count属性、CopyTo、Add、Remove、Clear方法
IList<T>
可以通过位置访问几何元素
ISet<T>
此集合不允许有重复的元素
IDictionary<K,V>
含有键值对的集合
ILookup<K,V>
含有键值对的集合，但可以通过一个键包含多个值
IComparer<T>
集合元素比较器，用于集合元素的排序
IEqualityComparer<T>
用于字典集合的比较器
IProducerConsumerCollection<T>
线程安全的集合
2.集合的基本操作
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace CollectionDemo
{
class Program
{
static void Main(string[] args)
{
#region 1、集合的基本操作
//1)、创建集合
//CreateCollection();
//2)、添加元素至集合
//AddCollection();
//3)、插入元素至集合
//InsertCollection();
//4)、访问集合中的元素
//VisitCollection();
//5)、遍历集合
//IteratesCollection();
//6)、删除集合中的元素
//DeleteCollection();
//7)、查找元素
//FindCollection();
//8）、集合排序
//SortCollection();
//9）、集合数据类型转换
//ConvertCollection();
//11)、集合常见扩展方法Select
//SelectCollection();
//12)、集合常见扩展方法Where
//WhereCollection();
#endregion 集合的基本操作
#region 2、常见集合的特性
//队列（Queue）
//QueueCollection();
//栈（Stack）
//StackCollection();
//链表(LinkedList)
//LinkedCollection();
//有序列表(SortedList<K,V>)
//SortedListCollection();
//字典 Lookup
//LookupCollection();
#endregion 常见集合的特性
}
#region 1、集合的基本操作
/// <summary>
/// 1)、创建集合
/// 使用默认的构造函数创建一个空集合，元素添加到集合之后，集合的容量就会扩大为4。
/// 当集合的容量被使用完，且还在向集合中添加元素时，集合的容量就会扩大成原来的2倍！
/// 可使用Capacity属性设置或访问集合的容量，使用Count属性访问集合的元素个数。
/// 也可使用TrimExcess方法调整集合容量，节省内存！
/// </summary>
public static void CreateCollection()
{
List<int> list = new List<int>();
//List<int> list = new List<int>(3); //指定初始容量
//创建集合时可以为集合设置初始值 如下：
//List<int> list1 = new List<int>() { 1,2,3,4,5,6,7,8,9,0};
//List<string> list2 = new List<string>() { "aa", "bb", "cc" };
for (int i = 0; i < 1025; i++)
{
if (list.Count == list.Capacity)
{
Console.WriteLine("容量使用量：" + list.Count + "/" + list.Capacity);
}
list.Add(i);
Console.WriteLine("容量使用量：" + list.Count + "/" + list.Capacity);
}
Console.WriteLine("容量使用量：" + list.Count + "/" + list.Capacity);
list.TrimExcess(); //整集合容量
Console.WriteLine("容量使用量：" + list.Count + "/" + list.Capacity);
Console.Read();
}
/// <summary>
/// 2)、添加元素集合
/// 为集合添加元素可使用Add方法，还可以使用AddRange方法一次添加多个元素，
/// 因为AddRange方法的参数是IEnumerable<T>类型的对象，所以可以添加数组到集合里。
/// </summary>
public static void AddCollection()
{
List<string> list = new List<string>();
list.AddRange(new string[] { "bb", "cc", "dd" }); //添加数组
list.AddRange(list);
list.Add("aa");
foreach (string item in list)
{
Console.WriteLine(item);
}
Console.Read();
}
/// <summary>
/// 3)、插入元素至集合
/// 插入元素可以使用Insert方法，同样使用InsertRange方法插入多个元素
/// </summary>
public static void InsertCollection()
{
List<string> list = new List<string>() { "aa", "bb","ff" };
list.Insert(2, "cc"); //插入元素
list.InsertRange(3, new string[] { "dd", "ee" }); //插入集合
foreach (string item in list)
{
Console.WriteLine(item);
}
Console.Read();
}
/// <summary>
/// 4)、访问集合中的元素
/// 使用索引器访问集合中某个位置的元素
/// </summary>
public static void VisitCollection()
{
List<string> list = new List<string>() { "aa", "bb", "cc", "ee" };
Console.WriteLine(list[1]); //访问第1个位置上的元素，下标从0开始
Console.Read();
}
/// <summary>
/// 5)、遍历集合
/// 集合的遍历，除了使用for、foreach外，还可以使用集合的Foreach方法，
/// 该方法的参数是一个Action<T>委托类型，可以使用Lambda表达式
/// </summary>
public static void IteratesCollection()
{
List<string> list = new List<string>() { "aa", "bb", "cc" };
list.ForEach(tmp => Console.WriteLine("元素：" + tmp));
//也可以这样使用：list.ForEach(Console.WriteLine);
Console.Read();
}
/// <summary>
/// 6)、删除集合中的元素
/// 使用RemoveAt删除指定位置的元素，使用Remove删除指定的元素，
/// 使用RemoveRange删除指定位置范围的元素，使用Clear删除所有元素
/// 使用RemoveAll选择删除的元素。注意：RemoveAll方法的参数是一个Predicate<T>委托类型
/// </summary>
public static void DeleteCollection()
{
List<string> list = new List<string>() { "12", "123", "1234", "12345" };
//删除长度小于4的元素
list.RemoveAll(x => { bool flag = x.Length < 4; return flag; });
list.ForEach(Console.WriteLine);
Console.Read();
}
/// <summary>
/// 7）、查找元素
/// 用于搜索的方法有：IndexOf、LastIndexOf、FindIndex、FindLastIndex、FindLast、Find、FindAll、Exists等方法。
/// IndexOf、LastIndexOf、FindIndex、FindLastIndex 方法用于搜索元素的位置。
/// FindLast、Find、FindAll 方法用于搜索满足条件的元素。
/// Exists 用于判断集合是否存在某些元素。
/// 参数可以使用Predicate<T>委托类型(Lambda表达式)的方法有：FindIndex、FindLastIndex、Find、FindLast、FindAll、Exists。
/// </summary>
public static void FindCollection()
{
List<string> list = new List<string>() { "12", "123", "1234", "12345" };
list = list.FindAll(x => { bool flag = x.Length < 4; return flag; });
list.ForEach(Console.WriteLine);
Console.Read();
}
/// <summary>
/// 8）、元素排序
/// 可以使用Sort方法对元素排序，也可以调用Reverse方法逆转集合顺序，Sort方法使用快速排序算法
/// Sort使用了几个重载的方法，可以传递的参数有泛型委托Comparison<T>和泛型接口IComparer<T>
/// </summary>
public static void SortCollection()
{
List<string> list = new List<string>() { "12", "123", "1234", "12345" };
//按字符串长度排序
list.Sort((x, y) => { return y.Length - x.Length; });
list.ForEach(Console.WriteLine);
Console.Read();
#region Sort例子
/*
// 把Student继承IComparer<Student>, IComparable<Student> 这两个接口，List<Student>就可以Sort了
public class Student : IComparer<Student>, IComparable<Student>
{
public string name;
public int num;
//下面是一些方法及属性
public int Compare(Student s1, Student s2)
{
if (s1.num > s2.num)
return 1;
if (s1.num < s2.num)
return -1;
return 0;
}
public int CompareTo(Student s)
{
return Compare(this, s);
}
}
//测试
List<Student> l = new List<Student>();
Student s1 = new Student();
s1.num = 5;
Student s2 = new Student();
s2.num = 3;
Student s3 = new Student();
s3.num = 6;
l.Add(s1);
l.Add(s2);
l.Add(s3);
l.Sort();
*/
#endregion Sort例子
}
/// <summary>
/// 9)、集合类型转换
/// 使用ConvertAll<TOutput>方法可以把集合里的所有元素转换成另一种类型，ConvertAll<TOutput>使用了Converter委托，其定义如下：
/// public sealeddelegate TOutput Converter<TInput, TOutput>(TInput from)
/// TInput是委托方法的参数类型，TOutput是委托方法的返回值类型。例如：
/// </summary>
public static void ConvertCollection()
{
List<string> list = new List<string>() { "12", "123", "1234", "12345" };
//把字符串集合转换成数字集合
List<int> array = list.ConvertAll<int>(tmp => Int32.Parse(tmp));
array.ForEach(Console.WriteLine);
Console.Read();
}
//10)、只读集合
//集合的AsReadOnly方法可以返回一个ReadOnlyCollection<T>类型的集合；
//ReadOnlyCollection<T>是一个只读集合类型，除了不能使用修改集合的方法与属性，其它与集合一样。
/// <summary>
/// 11)、集合常用的扩展方法[Select]
/// Select：将序列中的每个元素投影到新表中
/// </summary>
public static void SelectCollection()
{
List<int> list = new List<int>() { 1, 3, 5, 7, 9 };
IEnumerable<string> array = list.Select<int, string>(x => (x * x).ToString());
foreach (string s in array)
{
Console.WriteLine(s);
}
Console.Read();
}
/// <summary>
/// 12)、集合常用的扩展方法[Where]
/// Where：基于谓词筛选值序列
/// </summary>
public static void WhereCollection()
{
List<string> list = new List<string> { "1", "12", "123", "1234" };
//查询长度小于3的元素
IEnumerable<string> query = list.Where(temp => temp.Length < 3);
foreach (string s in query)
{
Console.WriteLine(s);
}
Console.Read();
}
#endregion 集合的基本操作
#region 2、常见集合的特性
//(1)非泛型集合对应的泛型集合
// 非泛型集合类 对应的泛型集合类
// ArrayList List<T>
// HashTable DIctionary<T>
// Queue Queue<T>
// Stack Stack<T>
// SortedList SortedList
/// <summary>
/// 1、队列（Queue）
/// 队列是其元素以先进先出的方式来处理的集合。该集合没有Add与Remove方法，其重要的方法：
/// Enqueue()：在队列的尾端添加元素
/// Dequeue()：在队列的头部读取并删除元素
/// Peek() ：只读取队列头部的元素
/// </summary>
public static void QueueCollection()
{
Queue<string> queue = new Queue<string>();
for (int i = 0; i < 5; i++)
{
queue.Enqueue(i.ToString());//在尾部添加元素
}
PrintQueue(queue);//输出元素
string s = queue.Dequeue(); //读取并删除头部元素
Console.WriteLine("读取并删除头部元素:" + s);
queue.Enqueue("5"); //在尾部添加元素
s = queue.Peek(); //读取头部元素
Console.WriteLine("读取头部元素:" + s);
PrintQueue(queue);//输出元素
Console.Read();
}
private static void PrintQueue(Queue<string> q)
{
IEnumerable<string> list = q.Where(t => true);
foreach (string s in list)
{
Console.WriteLine(s);
}
}
/// <summary>
/// 2、栈(Stack<T>)
/// 栈是一个后进先出的容器，其重要的方法：
/// Push() :在栈顶压入一个元素入栈
/// Pop() :从栈顶读取并删除一个元素
/// Peek() :只从栈顶读取一个元素而不删除
/// </summary>
public static void StackCollection()
{
Stack<string> stack = new Stack<string>();
for (int i = 0; i < 5; i++)
{
stack.Push(i.ToString()); //入栈
}
PrintStack(stack); //输出
string s = stack.Pop(); //读取并删除栈顶元素
Console.WriteLine("读取并删除栈顶元素:" + s);
s = stack.Peek();
Console.WriteLine("只读取栈顶元素:" + s);
PrintStack(stack);
Console.Read();
}
private static void PrintStack(Stack<string> stack)
{
IEnumerable<string> list = stack.Where(t => true);
foreach (var t in list)
{
Console.WriteLine(t);
}
}
/// <summary>
/// 3、链表（LinkedList<T>）
/// LinkedList<T>是一个双向链表。
/// 链表的优点是，如果将元素插入列表的中间位置，使用链表就会非常快，只需要修改下一个元素的Next引用与上一个元素的Previous引用。
/// 链表不能在集合中只存储元素，必须要把元素存到LinkedListNode<T>类型的对象中，LinkedListNode<T>定义了属性：List、Next、Value、Previous。
/// List属性返回与该节点相关的LinkedList<T>对象，Next、Previous用于遍历链表。
///
/// LinkedList<T>对象可以访问第一个和最后一个元素(Frist与Last)、
/// 在指定位置插入元素(AddAfter()、AddBefore()、AddFirst()、AddLast()方法)，
/// 删除指定位置的元素(ReMove()、ReMoveFirst()、RemoveLast()方法)，
/// 从链表的开头(Find())或结尾(FindLast())开始搜索元素。
/// </summary>
public static void LinkedCollection()
{
LinkedList<int> link = new LinkedList<int>();
LinkedListNode<int> node;
for (int i = 0; i < 10; i++)
{
node = new LinkedListNode<int>(i);
if (i % 2 == 0)
{
link.AddFirst(node); //从头部添加节点
}
else
{
link.AddLast(node);//从尾部添加节点
}
}
PrintLink(link); //输出元素
Console.Read();
}
private static void PrintLink(LinkedList<int> link)
{
IEnumerable<int> list = link.Where(t => true);
foreach (int t in list)
{
Console.WriteLine(t);
}
}
/// <summary>
/// 4、有序列表(SortedList<K,V>)
/// SortedList<K,V>是基于键对集合进行排序的集合类，它只允许每个键只有一个对应值，如果需要每个键对应多个值可以使用Lookup<K,V>。
/// 可以使用foreach遍历该集合，枚举器返回的是KeyValuePair<K,V>类型的元素。
/// 除了使用Add方法添加元素，还可以使用索引器添加。
/// </summary>
public static void SortedListCollection()
{
SortedList<string, string> sort = new SortedList<string, string>();
sort.Add("K1", "K1的值"); //Add方法添加元素
sort["K2"] = "K2的值"; //索引器添加元素
PrintSorted(sort);
Console.WriteLine("是否存在[K3]:" + sort.ContainsKey("K3"));
string value = null;
Console.WriteLine("是否存在[K2]:" + sort.TryGetValue("K2",out value));
Console.WriteLine("[K2的值]:" + value);
Console.Read();
}
private static void PrintSorted(SortedList<string, string> sort)
{
IEnumerable<KeyValuePair<string, string>> list = sort.Where(tmp => true);
foreach (KeyValuePair<string,string> item in list)
{
Console.WriteLine(item.Key + " ----> " + item.Value);
}
}
//5、字典
/*
* 字典中键的类型必须重写Object类的GetHashCode()方法。
* 只要字典类需要确定元素的位置，他就会调用GetHashCode()方法。除了实现GetHashCode()方法外，键类型还必须实现IEquatable<T>.Equals()方法，或重写Object类的Equals()方法。
* 因为不同的对象可能返回相同的散列码(GetHashCode方法返回值)，但是如果A.Equals(B)返回true，则A和B的散列码就必须相同。
* 这似乎有点奇怪，但这非常重要，因为字典的性能取决于GetHashCode()方法实现的代码。
*/
//字典1)： Dictionary<K,V>
// Dictionary<K,V>类支持每个键关联一个值，与SortedList<K,V>很类似,具体参考SortedList<K,V>。
/// <summary>
/// 字典2)：Lookup<K,V>
/// Lookup<K,V>类把键映射到一个值集上。
/// 创建Lookup<K,V>类对象必须调用ToLookup()扩展方法，该方法返回一个Lookup<K,V>对象。
/// ToLookup()方法需要一个Func<T,K>类型的委托参数，Func<T,K>类型定义了键的选择器。
/// ToLookup()用于对一个集合进行操作，创建一个1：n 的映射。 它可以方便的将数据分类成组，并生成一个字典供查询使用。
/// </summary>
public static void LookupCollection()
{
List<string> list = new List<string>() { "1", "12", "123", "1234", "a", "ab", "abc" };
var lookup = list.ToLookup(x => x.Length);
foreach (var t in lookup)
{
List<string> temp = t.ToList<string>(); //把一组数据转换成集合
temp.ForEach(x => Console.Write(x + "、")); //输出集合
Console.WriteLine();
}
Console.Read();
}
/*
* 字典3)：SortedDictionary<K,V>
* SortedDictionary<K,V>类是一个二叉搜索树，其中的元素根据键来排序，该键类型必须实现IComparable<T>接口。
* SortedDictionary<K,V>与SortedList<K,V>的区别：
* SortedList<K,V>类使用的内存比SortedDictionary<K,V>少。
* SortedDictionary<K,V>类的元素的插入与删除比较快。
* 在用于已排好序的集合，若不需要修改容量SortedList<K,V>会比较快。
* 区别的根本原因：SortedList<K,V>实现的是一个基于数组的集合，SortedDictionary<K,V>实现的是一个基于字典的集合。
*/
//6、集(ISet<T>接口)
//不包含重复元素的集合称为集，.NET Framework包含两个集(HashSet<T>和SortedSet<T>),它们都实现ISet<T>接口。
//HashSet<T>是不包含重复元素的无序列表，SortedSet<T>是不包含重复元素的有序列表。
#endregion 常见集合的特性
}
}