C#学习(十一)——Array和Collection

一、集合

集合重要且常用
孤立的数据是没有意义的，集合可以作为大量数据的处理，可进行数据的搜索、迭代、添加、删除。
C#中，所有集合都必须实现ICollection接口（数组Array除外）

集合	说明
`Array`	数组，固定长度、固定类型
`ArrayList`	列表，可变长度、任意类型
`List<T>`	列表，可变长度、固定类型
`Dictionary<T>`	字典，键值对结构
`Queue<T>`	队列，先进先出(FIFO)集合
`Stack<T>`	栈，后进先出(LIFO)集合
`IEnumerable<T>`	可迭代集合

C#集合的特点

[ 可以储存无限个元素（除了数组） ]
[ 任何一个集合都支持搜索、排序、复制、添加、删除等操作 ]

二、数组

特点
1.固定长度
2.有明确顺序

使用数组是十分安全的，不会返回任何不存在的数据
例如：

class Program
{static void Main(string[] args){string[] daysOfWeek ={"Monday","Tuesday","Wednesday","Thuresday","Friday","Saturday","Sunday"};foreach (string day in daysOfWeek){Console.WriteLine(day);}//零索引 0-indexedConsole.WriteLine(daysOfWeek[0]);//周一Console.WriteLine(daysOfWeek[1]);//周二//固定长度string[] monthsOfYear = new string[12];monthsOfYear[0] = "January";monthsOfYear[1] = "February";monthsOfYear[2] = "March";monthsOfYear[3] = "April";monthsOfYear[4] = "May";monthsOfYear[5] = "June";monthsOfYear[6] = "July";monthsOfYear[7] = "August";monthsOfYear[8] = "September";monthsOfYear[9] = "October";monthsOfYear[10] = "November";monthsOfYear[11] = "December";Console.Read();}
}

三、列表与数组列表

1.List
在底层实现中，list依然使用数组承载数据，不过在数组装满数据以后，list会立刻创建新的数组来代替旧的数组，并且把所有数据复制装载到新的数组中，因此列表又可以成为动态数组。列表的容量不仅可以动态调整，也可以手动调整，对系统的动态调优取得很大帮助。
数组的访问速度略高于列表，但是列表对于空间的利用优于数组。

//List 列表
List<string> daysOfWeek2 = new List<string>();
daysOfWeek2.Add("Monday");
daysOfWeek2.Add("Tuesday");
daysOfWeek2.Add("Wednesday");
daysOfWeek2.Add("Thuresday");
daysOfWeek2.Add("Friday");
daysOfWeek2.Add("Saturday");
daysOfWeek2.Add("Sunday");
//只需要在前面加上I就可以声明接口的列表
IList<string> daysOfWeek3 = new List<string>();

2.ArrayList

List支持泛型，ArrayList不支持泛型，仅能保存对象

ArrayList装载数据很方便，但是提取数据较为麻烦，需要进行拆箱，影响性能

//ArrayList
var array = new ArrayList();
array.Add(daysOfWeek);
array.Add("123");
array.Add(1);

3.List的基本操作
List的有参数构造器

//List的有参数构造器
var daysOfWeek4 = new List<string>(daysOfWeek);//数组
var daysOfWeek5 = new List<string>(daysOfWeek2);//列表
var daysOfWeek6 = new List<string>(7);
List<string> daysOfWeek7 = new List<string>
{"Monday","Tuesday","Wednesday","Thuresday","Friday","Saturday","Sunday"
};

列表的插入数据，可以使用Insert或者InsertRange

//列表插入,Insert,InsertRange
daysOfWeek7.InsertRange(2, daysOfWeek);//将daysOfWeek插入到第二个位置后

如果要将列表7插入到列表6的最前面

daysOfWeek6.InsertRange(0, daysOfWeek7);

但是更推荐

daysOfWeek7.AddRange(daysOfWeek6);

因为使用Insert操作，会自动将原来的列表分成两个列表，在进行插入操作，影响性能。
删除数据

//删除数据，RemoveAt, RemoveRange
daysOfWeek7.RemoveAt(0);
daysOfWeek7.RemoveRange(2, 6);
daysOfWeek7.Remove("Monday"); //只删除遍历到的第一个数据
daysOfWeek7.RemoveAll(i => i == "Monday");//删除遍历到的所有的Monday
daysOfWeek7.RemoveAll(i => i.Contains("day"));//删除所有包含day的数据

四、迭代器Enumerator与循环遍历ForEach

读取列表

//读取列表
var a = daysOfWeek6.Count;//读取数据个数
var b = daysOfWeek6.Capacity;//读取列表容量

索引器,方括号就是索引器,准确查找位置

//索引器,方括号就是索引器,准确查找位置
var c = daysOfWeek6[3];

迭代器,将集合按照一定规律全部访问一遍

var enumerator = daysOfWeek6.GetEnumerator();
var d = enumerator.Current;//迭代器当前所指的元素（此时为空)
enumerator.MoveNext();//此时指向第一个元素,遍历完成返回TRUE
while (enumerator.MoveNext())
{Console.WriteLine(enumerator.Current);//使用while循环，会在最后输出一个null，是由于Current悬空
}
//为了解决上面问题，所有可以使用foreach
foreach ( var day in daysOfWeek6)
{Console.WriteLine(day);
}

Foreach遍历时不允许容量发生变化，所有元素均为只读数据，不允许修改

但是我们可以举个例子
Customers.cs

public class Customer{public Customer(int id, string name, string address){Id = id;Name = name;Address = address;}public int Id { get; set; }public string Name { get; set; }public string Address { get; set; }}

Program.cs

List<Customer> customers = new List<Customer>();customers.Add(new Customer(1, "小赵", "广州"));customers.Add(new Customer(2, "小钱", "北京"));customers.Add(new Customer(3, "小王", "上海"));customers.Add(new Customer(4, "小孙", "深圳"));foreach(var customer in customers){customer.Name = "123";Console.WriteLine(customer.Name);}

此时，使用foreach却可以修改数据，为什么？
原因很简单，这里的customer是引用类型的数据，对于foreach，引用类型的数据本身地址是不改变的，因此这里的数据就可以完成修改。

IEumerable<T>与IEnumerator<T>

**由于不带泛型需要涉及到装箱拆箱，因此以下只讨论带泛型的版本 *

创建Bank类，使用迭代器遍历列表
Bank.cs

public class Bank : IEnumerable<Customer>
{public List<Customer> Customers { get; set; } = new List<Customer>();public Bank() {Customers.Add(new Customer(1, "小赵", "广州"));Customers.Add(new Customer(2, "小钱", "北京"));Customers.Add(new Customer(3, "小王", "上海"));Customers.Add(new Customer(4, "小孙", "深圳"));}public IEnumerator<Customer> GetEnumerator(){return Customers.GetEnumerator();}IEnumerator IEnumerable.GetEnumerator(){throw new NotImplementedException();}
}

Program.cs

var bank = new Bank();foreach (var item in bank)
{Console.WriteLine(item.Name);
}

下面，我们尝试自己创建一个迭代器，实现对于列表的遍历
创建MyEnumerator.cs

public class MyEnumerator<T> : IEnumerator<T>
{T[] _data;int _position = -1;//开始时，要让current悬空public MyEnumerator(T[] data){_data = data;}public T Current { get => _data[_position]; }object IEnumerator.Current { get => Current; }public void Dispose(){}public bool MoveNext(){_position++;return _position < _data.Length;}public void Reset(){_position = -1;}
}

MyList.cs

public class MyList<T> : IEnumerable<T>
{private T[] _data;int cuttentIndex;public MyList(int length){this._data = new T[length];cuttentIndex = 0;}public void Add(T item){_data[cuttentIndex] = item;cuttentIndex++;}public IEnumerator<T> GetEnumerator(){return new MyEnumerator<T>(_data);}IEnumerator IEnumerable.GetEnumerator(){throw new NotImplementedException();}
}

Bank.cs

public class Bank : IEnumerable<Customer>
{public MyList<Customer> Customers { get; set; } = new MyList<Customer>(4);public Bank() {Customers.Add(new Customer(1, "小赵", "广州"));Customers.Add(new Customer(2, "小钱", "北京"));Customers.Add(new Customer(3, "小王", "上海"));Customers.Add(new Customer(4, "小孙", "深圳"));}public IEnumerator<Customer> GetEnumerator(){return Customers.GetEnumerator();}IEnumerator IEnumerable.GetEnumerator(){throw new NotImplementedException();}
}

五、迭代与yield return

示例一个场景，有一百万个用户数据，我们需要调取前1000个客户数据

static void Main(string[] args)
{var customers = GetCustomers(1000000);foreach (var customer in customers){if(customer.Id < 1000){Console.WriteLine($"客户Id{customer.Id}, 客户姓名：{customer.Name}");}else{break;}}
}
static IEnumerable<Customer> GetCustomers(int count)
{var customers = new List<Customer>();for (int i = 0; i < count; i++){customers.Add(new Customer(i, $"Crackpot{i}", "天津"));}return customers;
}

此时，创建了1000000个数据，但是实际上只需要前1000个数据，对于其余的数据，内存空间完全浪费了，因为根本不会用到
因此，使用yield关键词，就可以实现一个懒加载的效果；yield语句的执行次数与if语句执行次数相同，可以极大地提升内存利用率。yield语句并不返回数据，而是返回数据的迭代。

static void Main(string[] args)
{var customers = GetCustomersYield(1000000);;foreach (var customer in customers){if(customer.Id < 1000){Console.WriteLine($"客户Id{customer.Id}, 客户姓名：{customer.Name}");}else{break;}}
}
static IEnumerable<Customer> GetCustomersYield(int count)
{var customers = new List<Customer>();for (int i = 0; i < count; i++){yield return new Customer(i, $"Crackpot{i}", "天津");

举例2

static void Main(string[] args)
{foreach (var i in Createnumerable()){Console.WriteLine(i);}
}
static IEnumerable<int> Createnumerable()
{yield return 3;yield return 2;yield return 1;
}

输出结果为3 2 1 ，可以看到yield可以实现非必要，不创建的原则

六、Benchmark性能基准测试

首先安装NuGet包

我们使用Benchmark来查看两种方法使用不使用yield的差距
创建BenchmarkTester.cs

[MemoryDiagnoser]
public class BenchmarkTester
{[Benchmark]public void ProcessCustomer(){var customers = GetCustomers(1000000);foreach (var customer in customers){if (customer.Id < 1000){Console.WriteLine($"客户id：{customer.Id}, 客户姓名：{customer.Name}");}else{break;}}}[Benchmark]public void ProcessCustomerYield(){var customers = GetCustomersYield(1000000);foreach (var customer in customers){if (customer.Id < 1000){Console.WriteLine($"客户id：{customer.Id}, 客户姓名：{customer.Name}");}else{break;}}}static IEnumerable<Customer> GetCustomersYield(int count){var customers = new List<Customer>();for (int i = 0; i < count; i++){yield return new Customer(i, $"Crackpot{i}", "天津");}}static IEnumerable<Customer> GetCustomers(int count){var customers = new List<Customer>();for (int i = 0; i < count; i++){customers.Add(new Customer(i, $"Crackpot{i}", "天津"));}return customers;}
}

然后再Program.cs中调用Benchmark进行测试var sumery = BenchmarkRunner.Run<BenchmarkTester>();
需要注意，需要在CMD中执行benchmark测试
找到项目文件，然后dotnet build -c Release
会生成文件于：项目名->bin->Release->net8.0->项目名.dll
dotnet 项目.dll
出现结果
测试结果
可以看到，使用yield的运行时间是不使用的大约1/2，而使用的内存分配仅为约1/671，足以看到yield对于系统运行性能的提升

七、数据搜索：字典

使用示例
program.cs

static void Main(string[] args)
{var customers = GetCustomerDictionary(1000000);customers.GetValueOrDefault(999999);var customer = customers[999999];Console.WriteLine($"客户id：{customer.Id}, 客户姓名：{customer.Name}");
}
static Dictionary<int, Customer> GetCustomerDictionary(int count)
{var customer = new Dictionary<int, Customer>();for (int i = 0; i < count; i++){customer.Add(i, new Customer(i, $"Crackpot{i}", "广州"));}return customer;
}

八、哈希表

C#中哈希表与字典几乎没有泛型，最显著区别是哈希表没有泛型而字典有泛型
哈希表的值均为object类型，因此难免会使用装箱或拆箱，因此非常耗时

static void Main(string[] args)
{var customerHashTable = GetCustomerHashTable(1000000);var customer = (Customer)customerHashTable[99999];Console.WriteLine($"客户id：{customer.Id}, 客户姓名：{customer.Name}");
}
static Hashtable GetCustomerHashTable(int count)
{var customer = new Hashtable();for (int i = 0; i < count; i++){customer.Add(i, new Customer(i, $"Crackpot{i}", "广州"));}return customer;
}

九、集合的交、并、差运算（HashSet）

HashSet并不常用，但是在处理一些特殊问题时，非常便捷。
示例为：查找公交线路系统
Program.cs

static void Main(string[] args)
{var database = new BusRouteRepository();Console.WriteLine("从哪里来？");string startingAt = Console.ReadLine();Console.WriteLine("到哪里去？");string goingTo = Console.ReadLine();var startingRoutes = database.FindBusTo(startingAt);var destination = database.FindBusTo(goingTo);HashSet<BusRoute> routes = new HashSet<BusRoute>(startingRoutes);routes.IntersectWith(destination);if(routes.Count > 0){foreach(var route in routes){Console.WriteLine($"乘坐公交车：{route}");}}else{Console.WriteLine("路线找不到");}Console.Read();
}

BusRoute.cs

public class BusRoute
{public int Number {  get; }public string Origin => PlacesServed[0];public string Destination => PlacesServed[^1];public string[] PlacesServed {  get; }public BusRoute(int number, string[] placesServed){this.Number = number;this.PlacesServed = placesServed;}public override string ToString() => $"{Number}: {Origin} -> {Destination}";public bool Serves(string destination){return Array.Exists(PlacesServed, place => place == destination);}
}

BusRouteRepository.cs

public class BusRouteRepository
{private readonly BusRoute[] _allRoutes;public BusRouteRepository(){_allRoutes = new BusRoute[]{new BusRoute(101, new string[] {"火车站","大学城","动物园","体育馆"}),new BusRoute(42, new string[] {"火车站","电子城","花园酒店","体育馆"}),new BusRoute(232, new string[] {"理工大学","海洋馆","购物中心","游泳馆","体育馆"}),new BusRoute(51, new string[] {"美食广场","长途汽车站","游乐园","机场"}),new BusRoute(6, new string[] {"南井村","双河营村","长途汽车站","火车站"}),};}public BusRoute[] FindBusTo(string location){return Array.FindAll(_allRoutes, route => route.Serves(location));}public BusRoute[] FindBusesBetween(string location1, string location2){return Array.FindAll(_allRoutes, route => route.Serves(location1) && route.Serves(location2));}
}