C# 数组之List<T>

一、引言

　　List<T>是ArrayList的泛型等效类，底层数据结构也是数组。

• 相比Array而言，可以动态的拓展数组长度、增删数据
• 相比ArrayList而言，由于声明的时候就已经规定 了 存储的数据类型<T>，因此，不存在对值类型的装箱和拆箱，性能得到提高。

---

二、函数

　　声明之前需要引用命名空间：using System.Collections.Generic;

初始化：

　　　　List<int> list =new List<int>{ 1,2,3};

　　或者

　　　　List<int> list =new List<int>();

　　　　list.Add(123);

　　　　

属性：

名称	描述
Count	实际个数
Capacity	最大容量

方法：

函数名	方法
Add 添加（单个）	void Add(T item); 将数据添加到数组末尾
AddRange 添加（多个）	AddRange(IEnumerable<T> collection);
Insert 插入	void Insert(int index, T item);
Clear 删除数据	void Clear(); 将数据全部删除
Remove 移除	bool Remove(T item); 移除数组中第一个item，并不是全部
	void RemoveAt(int index); 将下标为index的数据移除
	void RemoveRange(int index, int count); 将下标起始为index，长度为count的一段数据移除
	int RemoveAll(Predicate<T> match); 将满足条件的全部删除
Contains(T) 包含	bool Contains(T item); 判断数组是否包含item数据
Find 查找	T Find(Predicate<T> match); 搜索与指定谓词条件所匹配的元素，返回第一个匹配元素
	List<T> FindAll(Predicate<T> match); 搜索与指定谓词条件所匹配的元素，返回全部匹配元素
	int FindIndex(Predicate<T> match); 搜索与指定谓词条件所匹配的元素，返回第一个匹配元素的下标
	T FindLast(Predicate<T> match); 搜索与指定谓词条件所匹配的元素，返回最后一个匹配元素
	int FindLastIndex(Predicate<T> match); 搜索与指定谓词条件所匹配的元素，返回最后一个匹配元素的下标
Indexof 查找	int IndexOf(T item);
	int IndexOf(T item, int index);
	int IndexOf(T item, int index, int count);
GetRange 获得子串	List<T> GetRange(int index, int count) 返回从index开始，长度为count的数据
Reverse 翻转	void Reverse(); 将数组翻转
Sort 排序	void Sort();
	void Sort(IComparer<T> comparer);
	void Sort(int index, int count, IComparer<T> comparer);
	void Sort(Comparison<T> comparison);
CopyTo 复制	CopyTo(T[] array); 将整个数据复制到array里面，前提array数据长度>=源数组
	CopyTo(T[] array, int arrayIndex); 从目标数组array的下标arrayIndex开始，将整个数据，复制目标数组。 前提同上。
	CopyTo(int index, T[] array, int arrayIndex, int count); 从目标数组array的下标arrayIndex开始，将源数组从index开始，复制count个数据到目标数组。 前提同上。

数据访问：

　　List是数组，因此支持下标直接访问

　　List[index] = value

---

三、重点函数讲解：

---

 【删除Remove】

• bool Remove(T item);　　 移除数组中第一个item，并不是全部
  

• void RemoveAt(int index);     将下标为index的数据移除

• void RemoveRange(int index, int count);     将下标起始为index，长度为count的一段数据移除

• int RemoveAll(Predicate<T> match);       将满足条件的全部删除

前三个删除都特别简单，第四个RemoveAll可能见到的不多，但是又经常有这样的需求。下面结合例子讲解一下int RemoveAll(Predicate<T> match)：

例子：将List里面，包含"zxs"的字符串全部删除。

方式1：委托给函数

static bool IsContains_zxs(string str)
  {
        if (str.Contains("zxs"))
            return true;
        return false;
  }

public static void Main()
  {
       List<string> list = new List<string> { "zz","aacc","ss","zzzxssss","zxs","hello" };

　　　　list.RemoveAll(IsContains_zxs); 

　　　 foreach (var e in list) 
　　　　{
　　　　　 Console.Write(e + " "); 
　　　　} 
　}

输出结果：

zz aacc ss hello 

方式2：委托给拉姆达表达式

public static void Main()
  {
      List<string> list = new List<string> { "zz","aacc","ss","zzzxssss","zxs","hello" };

      list.RemoveAll(  str=>
        {
           　if (str.Contains("zxs"))
             　　 return true;
          　 return false;
        });

      foreach (var e in list)
      {
         Console.Write(e + " ");
      }
  }

输出结果：

zz aacc ss hello 

---

【查找Find】

• 　List<T> FindAll(Predicate<T> match);　　搜索与指定谓词条件所匹配的元素，返回全部匹配元素
•     .....xxx........　　其余几个Find函数，可类比

　　仔细看，发现Find 的参数是 Predicate<T>类型的。下面结合例子讲解详细使用方法：

例子：在list里面插入数据，然后利用FindAll函数找到所有大于等于5的数据。

方式1：委托给一个函数

static bool BigThen5(int value)
    {
        if (value >= 5)
            return true;
        return false;
    }

public static void Main()
    {
        List<int> list= new List<int> { 3,1,5,13,9};

        Predicate<int> pre = BigThen5;
        List<int> list_result = list.FindAll(pre);

        Console.Write("下面是满足条件的数据：");
        foreach (var e in list_result)
        {
            Console.Write(e + " ");
        }
    }

输出结果：

下面是满足条件的数据：5 13 9

方式2：委托给拉姆达表达式

public static void Main()
　　{
        List<int> list = new List<int> { 1,7,6,8,5,4,4,9,8,8};

        List<int> list_result = list.FindAll( value => {
             return value >= 5 ? true : false;
        } );

        Console.Write("下面是满足条件的数据：");
        foreach (var e in list_result)
        {
            Console.Write(e + " ");
        }
    }

输出结果：

下面是满足条件的数据：7 6 8 5 9 8 8

一般的查找，只是查找一个特定的数据，数据比较简单。但是想筛选复杂的数据，要么自己写函数封装，要么就可以利用List.FindAll函数来完成：在特定函数里面，将筛选条件补齐就好。

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

---

【排序Sort】

　　void Sort(IComparer<T> comparer);

　　一般的Sort()函数太简单，不再讲解，讲解下 参数为IComparer<T>的排序。下面结合例子，讲解;

方式1：

class M_CMP : IComparer<int>
    {
　　　　　//降序
        int IComparer<int>.Compare(int x, int y)
        {
            if (x < y)
                return 1;
            else
                return -1;
        }
    }

public static void Main()
    {
        List<int> list = new List<int> { 1,7,6,8,5,4,4,9,8,8};
        
        list.Sort(new M_CMP());

        foreach(var e in list)
        {
            Console.Write(e+" ");
        }
    }

输出结果：

9 8 8 8 7 6 5 4 4 1

方式2：

static int CMP(int a,int b)
    {
        //降序
        return b-a;
    }
  
public static void Main()
    {
        List<int> list = new List<int> { 1,7,6,8,5,4,4,9,8,8};
        
        list.Sort(CMP);

        foreach(var e in list)
        {
            Console.Write(e+" ");
        }
    }

输出结果：

9 8 8 8 7 6 5 4 4 1

 

---

四、总结

(1)即确保了类型安全。

(2)也取消了装箱和拆箱的操作。

(3)它融合了Array可以快速访问的优点以及ArrayList长度可以灵活变化的优点。

(4)在决定使用IList<T> 还是使用ArrayList类（两者具有类似的功能）时，记住IList<T> 类在大多数情况下执行得更好并且是类型安全的。

(5)如果对IList<T> 类的类型 T 使用引用类型，则两个类的行为是完全相同的。但是，如果对类型 T 使用值类型，则需要考虑实现和装箱问题。

(6)添加到ArrayList 中的任何引用或值类型都将隐式地向上强制转换为Object。如果项是值类型，则必须在将其添加到列表中时进行装箱操作，在检索时进行取消装箱操作。强制转换以及装箱和取消装箱操作都会降低性能；在必须对大型集合进行循环访问的情况下，装箱和取消装箱的影响非常明显。---微软