所属命名空间: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表达式只是让形式更简单。

技术
©2019-2020 Toolsou All rights reserved,
HashMap详解某东14薪变16薪,是诚意还是套路?浏览器内核(理解)java四大函数式接口(重点,简单)html写樱花树,写樱花树的作文让人意想不到的Python之樱花树(turtle库的华丽样式)os模块的简单使用