C# List 的一般用法

谁践踏了优雅 2023-02-28 15:17 61阅读 0赞

相关：

关于数组Array: [https://blog.csdn.net/qq\_42672770/article/details/104402551][https_blog.csdn.net_qq_42672770_article_details_104402551]

List泛型集合是C\#编程中的经常使用的**集合**之一，相对数组它可以动态的添加元素而不是声明的时候就必须指定大小。相对于ArrayList集合和Hashtable集合的优势是其元素的数据类型可以确定。而不是默认的父类类型object。

# List泛型集合的声明与元素添加 #

1.List泛型集合的声明：  
//声明一个List泛型集合的变量listNew  
List<string> listNew =**new List**<string>();

List<数据类型> 变量名=**new List**<数据类型>();

List<int> list1 = new List<int> { 1, 2, 3, 4, 5, };

### 、声明 ###

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

//T为列表中元素类型
    List<T> List = new List<T>();
    
    //当T为string时,举例：
    string[] nameArr = { "Ha", "Hunter", "Tom", "Lily", "Jay", "Jim", "Kuku", "Locu" };
    
    List<string> list = new List<string>(nameArr);

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

[回到顶部][Link 1]

### 3、添加 ###

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

//添加一个元素
    list. Add("lucy");
    //添加一组元素
    string[] temArr = { "Ha","Hunter", "Tom", "Lily", "Jay", "Jim", "Kuku",  "Locu" };
    list.AddRange(temArr);
    //插入元素
    list.Insert(1, "Hei");

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

[回到顶部][Link 1]

### 4、遍历元素(foreach) ###

foreach (string name in list)
    {
        Console.WriteLine(name);
    }

[回到顶部][Link 1]

### 5、删除、清空元素 ###

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

//删除一个值
    list.Remove("Hunter");
    //删除下标为index的元素
    list.RemoveAt(0);
    //从下标3开始，删除2个元素
    list.RemoveRange(3, 2);
    //清空元素
    list.Clear();

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

执行List的Clear方法和RemoveAll方法，List将清除指定元素，同时修改Count属性值，而Capacity属性值保持不变。

Clear方法和RemoveAll方法的区别是：Clear方法会清空所有元素，RemoveAll方法会清空满足指定条件的元素，当将条件设置为恒成立时，也会删除所有元素。

[回到顶部][Link 1]

### 6、Contains(是否包含某个元素) ###

bool blog = list.Contains("Hunter");

[回到顶部][Link 1]

### 7、排序Sort,倒序Reverse ###

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

//默认是元素第一个字母按升序
    list.Sort();
    //将List里面元素顺序反转
    list.Reverse();
    //从第二个元素开始，反转4个元素
    //结果list里最后的顺序变成"Ha", "Jay", "Lily", "Tom", "Hunter", "Jim", "Kuku",  "Locu"
    list.Reverse(1,4);

![复制代码][48304ba5e6f9fe08f3fa1abda7d326ab.png]

注意：  
1，以上代码声明的是一个string类型的泛型集合，其元素必须都为string型。  
2，可以声明其他元素的泛型集合，只需要将string改成对应类型便可。  
3.List泛型集合**添加元素的Add()方法**：  
代码案例：为第二步声明的集合添加五个元素：  
listNew**.Add**("一号元素");  
listNew**.Add**("二号元素");  
listNew**.Add**("三号元素");  
listNew**.Add**("四号元素");  
listNew**.Add**("五号元素");  
说明：  
1，**List泛型集合只能使用Add()方法添加元素，不能直接指定下标赋值如：“listnew\[0\]="一号元素";”这样的语句是不合法的。因为List泛型集合在声明之后没有添加元素之前是空的，直接指定下标赋值会导致索引超出范围。**  
2，一旦元素添加成功，指定下标修改集合中的元素，如在这个声明例子中我们可以将"二号元素"改成任何字符串，如“你好”。  
**listNew\[1\] = "你好";**  
3，List泛型集合和数组一样，其下标是从0开始的。  
因为元素是字符串，我们也可以添加一个字符串数组在集合中，使用AddRange()方法便可：  
案例)为listNew集合添加一个字符串数组  
代码：  
//声明一个字符串数组，有三个字符串元素  
string\[\] str=new string\[\]\{"六号元素","七号元素","八号元素"\};  
//使用AddRange()方法将元素添加到集合中  
listNew.AddRange(str);  
//添加成功  
添加完成之后该集合便有了8个元素。

# List泛型集合的常用属性 #

**Count属性**  
返回List泛型集合中元素的数量。  
如我们对上面已经添加过元素的集合获得其Count属性值  
Console.WriteLine(listNew.Count); //输出ListNew集合的元素数量  
输出值为:5

**Capacity属性**  
返回在不增加大小的情况下目前List泛型集合的容量  
List泛型集合在添加元素的时候容量是变化的，其过程（原理）如下：  
当添加元素的时候集合的容量不足以容纳所有元素就会自动增加目前元素数一倍的容量。  
所以在上面的例子中listNew集合的容量的增加过程如下：  
添加第一个元素的时候Capacity的值为1；  
添加第二个元素的时候Capacity的值为2；  
添加第三个元素的时候Capacity的值为4；  
添加第四个元素的时候Capacity的值为4；  
添加第五个元素的时候Capacity的值为8；

# List泛型集合的常用方法： #

### Add()方法 ###

添加元素的方法，前面已经讲过

### Clear()方法 ###

无返回值，清空集合中的所有元素  
案例：清空ListNew集合中的所有元素  
listNew.Clear();

### Contains()方法 ###

返回布尔型数据，参数为集合中元素的数据类型  
功能：检查集合中是否存在某元素  
案例：检查listNew集合中是否存在字符串元素"一号元素"。  
代码：listNew.Contains("一号元素");  
返回值为：true。

### Equals()方法 ###

比较两个List泛型集合是否相等  
举例，比较listNew集合与listold集合是否相等：  
代码：listNew.Equals(listold)； //本人就不声明listold集合了，理解Equals()方法即可。因为不常用。

### CompareTo ()方法 ###

这是字符串bai比较的函数，用法：  
string s1 = "c";  
string s2 = "b";  
if(s1.CompareTo(s2)==1)  
\{  
\}  
它有三个返回du值~：  
当zhis1>s2时，s1.CompareTo(s2)==1  
当s1=s2时，s1.CompareTo(s2)==0  
当s1<s2时，s1.CompareTo(s2)==-1  
以上为例，c的daoasc大于b的asc，所以返回1

### Indexof() ###

返回值为int，从索引位置0开始查找元素，并得到索引值  
比如我们要在listNew集合中查找元素"四号元素"的第一个索引位置(考虑到有多个"四号元素的情况")  
代码：  
listNew.Indexof("四号元素");  
返回值为：3。

### Insert()方法 ###

插入元素  
如我们在listNew集合的索引位置3上插入"三点五号元素"  
listNew.Insert(3,"三点五号元素");  
插入后元素数量变为增加了1，原来索引3位置上的元素在索引位置4上了，后面的元素全部向后移动了一格。

### Remove()方法 ###

删除指定元素  
如我们删除刚刚添加的"三点五号元素"  
代码：listNew.Remove("三点五号元素");  
删除这个元素之后后面的元素会上移一个索引位置

### RemoveAt()方法 ###

根据索引位置删除元素  
如：我们删除当前三号索引位置处的元素  
代码：listNew.RemoveAt(3);  
删除这个元素之后后面的元素会上移一个索引位置。

### Reserve()方法 ###

将集合中的所有元素反向排序  
如，我们将listNew集合中的所有元素反向排序  
代码：listNew.Reserve();  
反向排序之后集合中元素的索引会有改变

### ToArray()方法 ###

将集合转换为数组  
如我们将listNew集合转换为一个string数组  
string\[\] str=listNew.ToArray();

# **List的一般用法** #

所属命名空间: System.Collections.Generic  
public class List<T>:IList<T>,Icollection<T>,IEnumerable<T>,IList,Icollection,Ienumerable  
List<T>是ArrayList类的泛型等效类，该类使用大小可按需动态增加的数组实现IList<T>泛型接口

**(1)声明 List<T>mlist = new List<T>();**

string[] Arr = {"a","b","c"};
     List<string> mlist = new List<string>(Arr);

**(2)添加一个元素 List.Add(T item)　**

mlist.Add("d");

**(3)添加集合元素**

string[] Arr2 ={"f","g"."h"};
    mlist.AddRange(Arr2);

**(4)在index位置添加一个元素 Insert(int index,T item)**

mlist.Insert(1,"p");

**(5)遍历List中元素**

foreach(T element in mlist)  //T的类型与mlist声明时一样
    {
    　　Console.WriteLine(element);
    }

eg:

foreach(string s in mlist)
    {
        Console.WriteLine(s);
    }

**(6)删除元素**

List.Remove(T item); //删除一个值
        mlist.Remove("a");
    
        List.RemoveAt(int index); //删除下标为index的元素
        mlist.RemoveAt(0);
        
        List.RemoveRange(int index,int count); //下标index开始，删除count个元素
        mlist.RemoveRange(3,2);

**(7)判断某个元素是否在该List中**

List.Contains(T item)　返回true或false  
    eg:

if(mlist.Contains("g"))
           Console.WriteLine("g存在列表中");

else

mlist.Add("g");

**(8)给List里面元素排序 List.Sort()　默认是元素每一个字母按升序**  
   eg: mlist.Sort();

**(9)给List里面元素顺序反转 List.Reverse() 可以与List.Sort()配合使用**

**(10)List清空 List.Clear()**  
   eg: mlist.Clear();

**(11)获得List中元素数目 List.Count()　返回int值**  
   eg: mlist.count();

List进阶，强大方法**(12)List.FindAll方法：检索与指定谓词所定义的条件相匹配的所有元素 **

class program
        {
           static void Main(stirng[] args)
           {
             student stu = new student();
             stu.Name="arron";
             List<student> students= new List<student>();
             students.Add(stu);
             students.Add(new student("candy"));
             FindName myname = new FindName("arron");
             foreach(student s in students.FindAll(new Predicate<student>(myname.IsName)))
             { Console.WriteLine(s);}
           }
    
        public class student
        {
           public string Name{get;set;}
           public student(){}
           public override string ToString()
            {
                return string.Format("姓名:{0}",Name);
             }
         }
    
        public class FindName
        {
          private string _name;
          public FindName(string Name)
          {  this._name=Name;}
          public bool IsName(student s)
           { return (s.Name==_name)?true:false;}
        }

**(12)List.Find方法　搜索与指定谓词所定义的条件相匹配的元素，并返回整个List中的第一个匹配元素**

类似于C++ 中的STL C\#中也有List这样的数据结构方便开发者存储数据，我们常常会使用到sort，find等算法。  
以find为例，在msdn给出的原型如下

public T Find (  Predicate<T> match )

其中泛型T为list定义的时候用户决定的存储类型，Predicate match 是一个委托，可理解为函数指针，实质上被定义为  
public delegate bool Predicate (T obj)  
则开发者可以使用自己的函数作为find的条件，也可以简洁的使用一个匿名方法如

Stu find = sensorUpdList.Find(delegate(Stu temp)
    {
        return Stu .NO== NO; 
    });

特别注意的是，对于find返回的值，如果找到，就会返回list中的被找到的对象的值，如果找不到，就会返回该种对象的默认值。

如果对象为**引用类型**，对象的值为指向该对象的内存地址（可理解为指针），所以可以直接用那个返回值直接修改list内的元素，**此时对象的默认值为null**

如果对象为**值类型** ，**对象的值就是对象本身**，返回值传回的是**该对象的一个拷贝**，对传回那个**对象的修改不能影响list中的元素**。

eg:

//Predicate是对方法的委托，如果传递给它的对象与委托定义的条件匹配，则该方法返回true,当前List的元素  
　　被逐个传递给Predicate委托，并在List中间前移动，从第一个元素开始，到最后一个元素结束，当找到匹配项  
　　时处理停止

第一种方法 委托给Lambda表达式：  
　　eg:

string listFind = mlist.Find(name=>
           {
              if(name.length>3)
                 return true;
              return false;
           });

第二种方法 委托给一个函数  
    eg:

public bool ListFind(string name)
            {
                if (name.Length > 3)
                {
                    return true;
                }
                return false;
            }

这两种方法的结果是一样的

**(13) List.FindLast方法  public T FindLast(Predicate<T> match);确定是否 List 中的每个元素都与指定的谓词所定义的条件相匹配。用法与List.Find相同。**

**(14) List.TrueForAll方法：  确定是否 List 中的每个元素都与指定的谓词所定义的条件相匹配。**

public bool TrueForAll(Predicate<T> match);

**(15) List.Take(n)：  获得前n行 返回值为IEnumetable<T>，T的类型与List<T>的类型一样**

E.g.：

IEnumerable<string> takeList=  mList.Take(5);

foreach (string s in takeList)

Console.WriteLine("element in takeList: " + s);

这时takeList存放的元素就是mList中的前5个

**(16) List.Where方法：检索与指定谓词所定义的条件相匹配的所有元素。跟List.FindAll方法类似。**

E.g.：

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的元素

**(17)List.RemoveAll方法：移除与指定的谓词所定义的条件相匹配的所有元素。**

public int RemoveAll(Predicate<T> match);

E.g.：

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之后的元素。

在C\#的List集合中有时候需要获取指定索引位置范围的元素对象来组成一个新的List集合，此时就可使用到List集合的扩展方法GetRange方法，GetRange方法专门用于获取List集合指定范围内的所有值，GetRange方法签名为List<T> GetRange(int index, int count)，index为开始索引位置，count为从index开始获取元素的个数。

例如有个List<int>的集合list1,内部存储10个数字，需要获取list1集合从第5个数开始，连续的5个元素组成新的集合，可使用下列语句：

List<int> list1 = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    var resultList= list1.GetRange(4, 5);
    计算结果为，resultList集合的元素为5,6,7,8,9

string str = str.Substring(0, i);//截取字符串前i位
      string str = str.Remove(i, str.Length - i);//移除字符串i位后面的字符=截取字符串前i位
      string str = str.Remove(0, i);//截取字符串i位之后的字符串
      string str = str.Substring(i);//截取字符串i位之后的字符串
      string str = str.Substring(str.Length - i);//截取字符串后i位
      string str = str.Remove(0, str.Length - i);//截取字符串后i位
      string str = str.Substring(0, str.Length - i);//去掉字符串后i位
      string str = str.Remove(str.Length - i, i);//去掉字符串后i位
      string str = str.Replace("abc", "ABC");//替换字符串中的字符串
      string str = str.ToUpper();//小写字母转换成大写字母
      string str = str0.ToLower();//大写字母转换成小写字母
      string str= str.Substring(str.Length - 1, 1);//截取字符串最后一位
      int n = str.IndexOf("123");
      string str = str.Substring(1, 4);//截取从开始字符串到结束字符串范围
      
      string s = "1,2,3,4,5,6,7,8,9,10";
      string[] strArray = s.Split(','); //字符串转数组
      string str = string.Join(",", strArray);//数组转字符串
      List<string> list = new List<string>(s.Split(','));//字符串转List
      string str = string.Join(",", list.ToArray());//List转字符串
      string[] str = list.ToArray();//List转数组
      List<string> list_ = new List<string>(str15);//数组转List

## ##

### FirstOrDefault ###

1. Find方法只能在List<T>上使用，而后者能更广泛应用在IEnemerable<T>上。

Find最终是建立在Array的查找之上，而在IEnemerable上的FirstOrDefault是使用foreach查找的。因此，Find速度会比FirstOrDefault快很多，据测试可能会快一倍以上。

2. First：取序列中满足条件的第一个元素，如果没有元素满足条件，则抛出异常   
3. FirstOrDefault：取序列中满足条件的第一个元素，如果没有元素满足条件，则返回默认值（对于可以为null的对象，默认值为null，对于不能为null的对象，如int，默认值为0）   
First、FirstOrDefault的区别在于：当没有元素满足条件时，一个抛出异常，一个返回默认值。   
因此，在使用时，一定要注意这个区别：   
1、当确信序列中一定有满足条件的元素时，使用First方法，取到元素后，无需判断是否为null   
2、当序列中可能找不到满足条件的元素时，使用FirstOrDefault方法，然后，一定要对返回值是否为null，进行不同的处理

[https_blog.csdn.net_qq_42672770_article_details_104402551]: https://blog.csdn.net/qq_42672770/article/details/104402551
[48304ba5e6f9fe08f3fa1abda7d326ab.png]: /images/20230209/224ed4c5b6a641d08a63192243f586aa.png
[Link 1]: https://www.cnblogs.com/cang12138/p/6669656.html#_labelTop