List泛型⽤法（半转载半原创）⽹上的List泛型⽤法，未验证，⽬测基本正确，教学⽤资料。
1、 List的基础、常⽤⽅法：
声明：
1、List<T> mList = new List<T>();
T为列表中元素类型，现在以string类型作为例⼦
<： List<string> mList = new List<string>();
2、List<T> testList =new List<T> (IEnumerable<T> collection);
以⼀个集合作为参数创建List
<：
string[] temArr = { "Ha", "Hunter", "Tom", "Lily", "Jay", "Jim", "Kuku", "Locu" };
List<string> testList = new List<string>(temArr);
添加元素:
1、 List. Add(T item) 添加⼀个元素
<： mList.Add("John");
2、 List. AddRange(IEnumerable<T> collection) 添加⼀组元素
<：
string[] temArr = { "Ha","Hunter", "Tom", "Lily", "Jay", "Jim", "Kuku", "Locu" };
mList.AddRange(temArr);
3、Insert(int index, T item); 在index位置添加⼀个元素
<： mList.Insert(1, "Hei");
遍历List中元素:
foreach (T element in mList) T的类型与mList声明时⼀样
{
Console.WriteLine(element);
}
<：
foreach (string s in mList)
{
Console.WriteLine(s);
}
删除元素:
1、 List. Remove(T item) 删除⼀个值
<： mList.Remove("Hunter");
2、 List. RemoveAt(int index); 删除下标为index的元素
<： mList.RemoveAt(0);
3、 List. RemoveRange(int index, int count);
从下标index开始，删除count个元素
<： mList.RemoveRange(3, 2);
判断某个元素是否在该List中：
List. Contains(T item) 返回true或false，很实⽤
<：
if (mList.Contains("Hunter"))
{
Console.WriteLine("There is Hunter in the list");
}
else
{
mList.Add("Hunter");
Console.WriteLine("Add Hunter successfully.");
}
给List⾥⾯元素排序：
List. Sort () 默认是元素第⼀个字母按升序
<： mList.Sort();
给List⾥⾯元素顺序反转：
List. Reverse () 可以与List. Sort ()配合使⽤，达到想要的效果
<： mList.Sort();
List清空：List. Clear ()
<： mList.Clear();
获得List中元素数⽬：
List. Count () 返回int值（转者注：实测不带“（）”）
<：
int count = mList.Count();
Console.WriteLine("The num of elements in the list: " +count);
（转者注：学⽣基础学习到此为⽌！）
2、 List的进阶、强⼤⽅法：
举例⽤的List：
string[] temArr = { Ha","Hunter", "Tom", "Lily", "Jay", "Jim", "Kuku", " "Locu" };
mList.AddRange(temArr);
List.Find ⽅法：搜索与指定谓词所定义的条件相匹配的元素，并返回整个 List 中的第⼀个匹配元素。
public T Find(Predicate<T> match);
Predicate是对⽅法的委托，如果传递给它的对象与委托中定义的条件匹配，则该⽅法返回 true。当前 List 的元素被逐个传递给Predicate委托，并在 List 中向前移动，从第⼀个元素开始，到最后⼀个元素结束。当到匹配项时处理即停⽌。
Predicate 可以委托给⼀个函数或者⼀个拉姆达表达式:
委托给拉姆达表达式：
<：
string listFind = mList.Find(name => //name是变量，代表的是mList
{ //中元素，⾃⼰设定
if (name.Length > 3)
{
return true;
}
return false;
});
Console.WriteLine(listFind); //输出是Hunter
委托给⼀个函数：
<：
string listFind1 = mList.Find(ListFind); //委托给ListFind函数
Console.WriteLine(listFind); //输出是Hunter
ListFind函数：
public bool ListFind(string name)
{
if (name.Length > 3)
{
return true;
}
return false;
}
这两种⽅法的结果是⼀样的。
List.FindLast ⽅法：搜索与指定谓词所定义的条件相匹配的元素，并返回整个 List 中的最后⼀个匹配元素。
public T FindLast(Predicate<T> match);
⽤法与List.Find相同。
List.TrueForAll⽅法：确定是否中的每个元素都与指定的谓词所定义的条件相匹配。public bool TrueForAll(Predicate<T> match);
委托给拉姆达表达式：
<：
bool flag = mList.TrueForAll(name =>
{
if (name.Length > 3)
{
return true;
}
else
{
return false;
}
}
);
Console.WriteLine("True for all: "+flag); //flag值为false
委托给⼀个函数，这⾥⽤到上⾯的ListFind函数：
<：
bool flag = mList.TrueForAll(ListFind); //委托给ListFind函数
Console.WriteLine("True for all: "+flag); //flag值为false
这两种⽅法的结果是⼀样的。
List.FindAll⽅法：检索与指定谓词所定义的条件相匹配的所有元素。
public List<T> FindAll(Predicate<T> match);
<：
List<string> subList = mList.FindAll(ListFind); //委托给ListFind函数
foreach (string s in subList)
{
Console.WriteLine("element in subList: "+s);
}
这时subList存储的就是所有长度⼤于3的元素
List.Take(n)：获得前n⾏返回值为IEnumetable<T>，T的类型与List<T>的类型⼀样
<：
IEnumerable<string> takeList= mList.Take(5);
foreach (string s in takeList)
{
Console.WriteLine("element in takeList: " + s);
}
这时takeList存放的元素就是mList中的前5个
List.Where⽅法：检索与指定谓词所定义的条件相匹配的所有元素。跟List.FindAll⽅法类似。
<：
IEnumerable<string> whereList = mList.Where(name =>
{
if (name.Length > 3)
{
return true;
}
else
{
return false;
}
foreach (string s in subList)
{
Console.WriteLine("element in subList: "+s);
}
这时subList存储的就是所有长度⼤于3的元素
List.RemoveAll⽅法：移除与指定的谓词所定义的条件相匹配的所有元素。
public int RemoveAll(Predicate<T> match);
<：
mList.RemoveAll(name =>
{
if (name.Length > 3)
{
return true;
}
else
{
return false;
}
});
foreach (string s in mList)
{
Console.WriteLine("element in mList: " + s);
}
这时mList存储的就是移除长度⼤于3之后的元素。
//转者以为以下内容不重要
List 是⼀个泛型链表...T表⽰节点元素类型
⽐如
List<int> intList；表⽰⼀个元素为int的链表
intList.Add(34); //添加
intList.Remove(34);//删除
intList.RemoveAt(0); //删除位于某处的元素
intList.Count; //链表长度
还有Insert,Find,FindAll,Contains等⽅法，也有索引⽅法 intList[0] = 23;
1.减少了装箱拆箱
2.便于编译时检查数据类型
List 就相当于 System.Collections命名空间⾥⾯的List
引⾃killer的博客，原⽂：
感谢作者！未查看到版权信息，如有侵权，请告知。
以下内容原创
通过上⾯的内容，我们可以看到以list为代表的集合，有很多功能，配合拉姆达表达式（委托）威⼒更强⼤。
为了更深⼊体会它的⼯作原理，我们来看看下⾯的代码：
static void Main(string[] args)
{
MyList<int> list ,t;
int[] init_value = new int[25];
for (int i = 0; i < init_value.Length; i++)
{
init_value[i] = i + 1;
}
list = new(init_value);
list.ForEach(x => Console.Write($"InForeach:{x} "));
t = list.Where(x => x % 5 == 0);
t.show();
Console.ReadKey();
}
把MyList看成List类，⾥⾯的⼀些⽤法（ForEach,Where等）并不违和。
（提⽰：new()直接调⽤构造函数是c#9中的语法，.NET FrameWorks⽬前并不⽀持，⼤家按需⾃⾏修改）
程序运⾏结果：
InForeach:1 InForeach:2 InForeach:3 InForeach:4 InForeach:5 InForeach:6 InForeach:7 InForeach:8 InForeach:9 InForeach:10 InForeach:11 InForeach:12 InForeach:13 InForeach:14 InForeach:15 InForeach:16 InForeach:17 InForeach：其实，MyList是我们⾃⼰写的⼀个类。利⽤泛型，写出⽤委托做参数的⽅法，就可以模仿系统List泛型的⼀些功能，也可以更好地理解集合的使⽤。
参考代码如下：
2 {
3public T[] Mydata { get; set; }
4public MyList()
5 {
6 }
7public MyList(T[] xx)
8 {
9 Mydata = xx;
10 }
11public void show()
12 {
13foreach (var item in Mydata)
14 {
15 Console.Write(item+",");
16 }
17 Console.Write("\b ");
18 }
19public void ForEach(Action<T> x)
20 {
21foreach (var item in Mydata)
22 {
23 x(item);
24 }
25 }
26public MyList<T> Where(Func<T,bool> x)
27 {
28 MyList<T> myList=new MyList<T>();
29 List<T> t = new();
30foreach (var item in Mydata)
writeline函数31 {
32if(x(item))
33 {
34 t.Add(item);
35 }
36 }
37 myList.Mydata = t.ToArray();
38return myList;
39 }
40 }
集合并不神秘，了解它，使⽤它，不要当作神去供着。
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论