所属命名空间：System.Collections.Generic
List<T>类是 ArrayList 类的泛型等效类。该类使用大小可按需动态增加的数组实现 IList<T> 泛型接口。
泛型的好处： 它为使用c#语言编写面向对象程序增加了极大的效力和灵活性。不会强行对值类型进行装箱和拆箱，或对引用类型进行，向下强制类型转换，所以性能得到提高。
性能注意事项： List[T]两点优势
(1)在决定使用IList<T> 还是使用ArrayList类（两者具有类似的功能）时，记住IList<T> 类在大多数情况下执行得更好并且是类型安全的。
(2)如果对IList<T> 类的类型 T 使用引用类型，则两个类的行为是完全相同的。但是，如果对类型 T 使用值类型，则需要考虑实现和装箱问题。
添加到ArrayList 中的任何引用或值类型都将隐式地向上强制转换为Object。如果项是值类型，则必须在将其添加到列表中时进行装箱操作，在检索时进行取消装箱操作。强制转换以及装箱和取消装箱操作都会降低性能；在必须对大型集合进行循环访问的情况下，装箱和取消装箱的影响非常明显。---微软
1.添加元素
(1)List. Add(T item) 添加一个元素，E.g.： mList.Add("John");
(2)List. AddRange(IEnumerable<T>collection) 添加一组元素，
E.g.： string[] temArr = { "Ha","Hunter", "Tom","Lily", "Jay","Jim", "Kuku", "Locu"};
mList.AddRange(temArr);
(3)在index位置添加一个元素， E.g.： mList.Insert(1, "Hei");
2.删除元素
(1)删除一个值，E.g.： mList.Remove("Hunter");
(2)删除下标为index的元素，E.g.： mList.RemoveAt(0);
(3)从下标index开始，删除count个元素， E.g.： mList.RemoveRange(3, 2);
3.排序元素
(1)默认是元素第一个字母按升序，E.g.： mList.Sort();
(2)顺序反转，E.g.：List. Reverse () ；可以与List. Sort ()配合使用，达到想要的效果
4.查找元素
(1)List.Find 方法：搜索与指定谓词所定义的条件相匹配的元素，并返回整个 List 中的第一个匹配元素。
Predicate是对方法的委托，如果传递给它的对象与委托中定义的条件匹配，则该方法返回 true。当前 List 的元素被逐个传递给Predicate委托，并在 List 中向前移动，从第一个元素开始，到最后一个元素结束。当找到匹配项时处理即停止。
public T Find(Predicate<T>match);
委托给拉姆达表达式：
E.g.：
委托给一个函数：
1 string listFind1 = mList.Find(ListFind); //委托给ListFind函数
2 Console.WriteLine(listFind); //输出是Hunter
3
4 //ListFind函数：
5 public bool ListFind(string name)
6 {
7 if(name.Length > 3)
8 {
9 returntrue;
10 }
11 returnfalse;
12 }
这两种方法的结果是一样的。
List.FindLast 方法：搜索与指定谓词所定义的条件相匹配的元素，并返回整个 List 中的最后一个匹配元素。
(2)List.TrueForAll方法： 确定是否 List 中的每个元素都与指定的谓词所定义的条件相匹配。
publicbool TrueForAll(Predicate<T> match);
委托给拉姆达表达式：
1 bool flag=mList.TrueForAll(name=>)
2 {
3 if (name.Length>3)
4 {
5 return true;
6 }
7 else
8 {
9 return false;
10 }
11 }
12 Console.WriteLine("True for all:"+flag);//flag 的值为False
委托给一个函数，这里用到上面的ListFind函数：
1 bool flag = mList.TrueForAll(ListFind); //委托给ListFind函数
2 Console.WriteLine("True forall: "+flag); //flag值为false
(3)List.FindAll方法：检索与指定谓词所定义的条件相匹配的所有元素。
publicList<T>FindAll(Predicate<T> match);
1 E.g.：
2
3 List<string> subList =mList.FindAll(ListFind); //委托给ListFind函数
4
5 foreach (string s in subList)
6
7 {
8
9 Console.WriteLine("element in subList: "+s);
10
11 }
12
13 //这时subList存储的就是所有长度大于3的元素
14
15 //List.Take(n)： 获得前n行 返回值为IEnumetable<T>，T的类型与List<T>的类//型一样
16
17 E.g.：
18
19 IEnumerable<string>takeList= mList.Take(5);
20
21 foreach(string s intakeList)
22
23 {
24
25 Console.WriteLine("element in takeList: " + s);
26
27 }
28
29 // 这时takeList存放的元素就是mList中的前5个
(3)List.Where方法：检索与指定谓词所定义的条件相匹配的所有元素。跟List.FindAll方法类似。
(4)List.RemoveAll方法：移除与指定的谓词所定义的条件相匹配的所有元素。
C# List<T>排序总结
这里有很多种方法对List进行排序，本文总结了三种方法，但多种实现。
1.对基础类型排序
方法一：
调用sort方法，如果需要降序，进行反转：
List<int> list = new List<int>();
list.Sort();// 升序排序
list.Reverse();// 反转顺序方法二：
使用lambda表达式，在前面加个负号就是降序了
List<int> list= new List<int>(){5,1,22,11,4};
list.Sort((x, y) => x.CompareTo(y));//升序
list.Sort((x, y) => -x.CompareTo(y));//降序接下来是对非基本类型排序，以一个类为例。
2.准备
首先写一个类用于排序，里面有两个属性，一个构造方法，重写了ToString方法：
class People
{
private int _id;
private string _name;
public People(int id,string name)
{
this._id = id;
this.Name = name;
}
public int Id
{
get
{
return _id;
}
set
{
_id = value;
}
}
public string Name
{
get
{
return _name;
}
set
{
_name = value;
}
}
//重写ToString
public override string ToString()
{
return "ID:"+_id+" Name:"+_name;
}
}然后添加一些随机数据，仍希望用Sort排序
List<People> list = new List<People>();
Random r = new Random();
//添加数据
for(int i = 0; i < 10; i++)
{
int j = r.Next(0, 10);
list.Add(new People(j, "name" + j));
}
Console.WriteLine("排序前：");
foreach(var p in list)
{
Console.WriteLine(p);
}
list.Sort();//排序
Console.WriteLine("排序后：");
foreach (var p in list)
{
Console.WriteLine(p);
}很不幸，前面输出正常，后面抛异常了：
查看Sort源码可知它有如下几个重载：
第三和第四个差不多。
3.实现IComparable接口
可以看到它只有一个方法，我们只需要修改类本身
class People: IComparable<People>
{
private int _id;
private string _name;
public People(int id,string name)
{
this._id = id;
this.Name = name;
}
public int Id
{
get
{
return _id;
}
set
{
_id = value;
}
}
public string Name
{
get
{
return _name;
}
set
{
_name = value;
}
}
//重写的CompareTo方法，根据Id排序
public int CompareTo(People other)
{
if (null == other)
{
return 1;//空值比较大，返回1
}
//return this.Id.CompareTo(other.Id);//升序
return other.Id.CompareTo(this.Id);//降序
}
//重写ToString
public override string ToString()
{
return "ID:"+_id+" Name:"+_name;
}
}
4.实现IComparer接口
我们首先来看看这个接口：
public interface IComparer<in T>
{
// Parameters:
// x:
// The first object to compare.
//
// y:
// The second object to compare.
//
// Returns:
// A signed integer that indicates the relative values of x and y, as shown in the
// following table.Value Meaning Less than zerox is less than y.Zerox equals y.Greater
// than zerox is greater than y.
int Compare(T x, T y);
}重点就看返回值，小于0代表x < y,等于0代表x=y，大于0代表x > y.
下面看一下类的实现，非常简单，一句代码：
class People:IComparer<People>
{
private int _id;
private string _name;
public People()
{
}
public People(int id,string name)
{
this._id = id;
this.Name = name;
}
public int Id
{
get
{
return _id;
}
set
{
_id = value;
}
}
public string Name
{
get
{
return _name;
}
set
{
_name = value;
}
}
//Compare函数
public int Compare(People x, People y)
{
return x.Id.CompareTo(y.Id);//升序
}
//重写ToString
public override string ToString()
{
return "ID:"+_id+" Name:"+_name;
}
}但是还没完，我们其实是用了第2点说的第一个重载方法，所以List还需要参数：
IComparer<People> comparer = new People();
list.Sort(comparer);- 1
- 2
5.更简单的
虽然想实现排序上面的接口代码也不多，但有时候只是偶尔排序，并不像修改类，怎么办呢？当然有更简单的方法，委托和lambda表达式：
所以就有了下面的代码，不需要修改类，只需要用委托构造重载而已：
list.Sort(
delegate(People p1,People p2)
{
return p1.Id.CompareTo(p2.Id);//升序
}
);当然，lambda表达式实现更简单：
list.Sort((x,y)=> { return x.Id.CompareTo(y.Id); });- 1
6.OrderBy方法
此方法将排序好的list再赋给原来的list，也可以给其他的。
list = list.OrderBy(o => o.Id).ToList();//升序
list = list.OrderByDescending(o => o.Id).ToList();//降序7.多权重排序
排序的方法我就知道这么多了（其实有更多），接下来还有一个问题，如果希望当ID相同时比较Name，上面的代码就需要改改了。
其中，接口IComparable这样写：
//重写的CompareTo方法，根据Id排序
public int CompareTo(People other)
{
if (null == other)
{
return 1;//空值比较大，返回1
}
//等于返回0
int re = this.Id.CompareTo(other.Id);
if (0 == re)
{
//id相同再比较Name
return this.Name.CompareTo(other.Name);
}
return re;
}IComparer和delegate还有lambda里可以这样：
public int Compare(People x, People y)
{
int re = x.Id.CompareTo(y.Id);
if (0 == re)
{
return x.Name.CompareTo(y.Name);
}
return re;
}OrderBy方法有点不同：
list = list.OrderBy(o => o.Id).ThenBy(o=>o.Name).ToList();
list = list.OrderByDescending(o => o.Id).ThenByDescending(o=>o.Name).ToList();//降序8.总结
虽然说了那么多，其实说到底也就三种方法，两个接口和OrderBy方法，lambda表达式只是让形式更简单。
