Summary of usage of C# List

Namespace: System.Collections.Generic
public class List : IList, ICollection, IEnumerable, IList, ICollection, IEnumerable

List< T>Class is the generic equivalent of the ArrayList class. This class implements the IList generic interface using an array whose size can be dynamically increased as needed.

Benefits of generics: It adds great efficiency and flexibility to writing object-oriented programs using the C# language. There is no forced boxing and unboxing of value types, or downcasting of reference types, so performance is improved.

Performance Notes:

When deciding to use IList or the ArrayList class (both have similar functionality), remember that the IList class performs in most cases Better and type-safe.

If you use a reference type for type T of the IList class, the behavior of the two classes is exactly the same. However, if you use a value type for type T, you need to consider implementation and boxing issues.

"Any reference or value type added to the ArrayList will be implicitly cast up to Object. If the item is a value type, it must be boxed when it is added to the list. Unboxing operations are performed during retrieval. Casts and boxing and unboxing operations all reduce performance; the impact of boxing and unboxing is significant in situations where large collections must be iterated over.”

1. Basic and common methods of List:

Declaration:
1. List mList = new List();
T is the element type in the list , now take the string type as an example

E.g.: List mList = new List();

2, List testList =new List (IEnumerable< ;T> collection);

Create a List with a collection as a parameter

E.g.:
string[] temArr = { "Ha", "Hunter", "Tom", "Lily ", "Jay", "Jim", "Kuku", "Locu" };
List testList = new List(temArr);

Add elements:

1. List. Add(T item) Add an element

E.g.：mList.Add("John");

2. List. AddRange(IEnumerable collection) Add a set of elements

E.g.：
string[] temArr = { "Ha","Hunter", "Tom", "Lily", "Jay", "Jim", "Kuku" , "Locu" };
mList.AddRange(temArr);

3. Insert(int index, T item); Add an element at the index position

E.g.: mList.Insert (1, "Hei");

Traverse the elements in the List:

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

E.g.：

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

Delete the element:

1. List. Remove(T item) deletes a value

E.g.: mList.Remove("Hunter");

2. List. RemoveAt(int index); Delete the next Element marked index

E.g.: mList.RemoveAt(0);

3. List.RemoveRange(int index, int count);

Start from the subscript index , delete count elements

E.g.: mList.RemoveRange(3, 2);

Determine whether an element is in the List:

List. Contains(T item ) Returns true or false, very practical

E.g.:

if (mList.Contains("Hunter"))
{
    Console.WriteLine("There is Hunter in the list");
}
else
{
    mList.Add("Hunter");
    Console.WriteLine("Add Hunter successfully.");
}

Sort the elements in the List:

##List. Sort () Default Is the first letter of the element in ascending order

E.g.: mList.Sort();

Reverse the order of the elements in the List:

List. Reverse () Can be used with List . Sort () is used together to achieve the desired effect

E.g.: mList.Sort();

Clear List: List. Clear ()
E.g.: mList.Clear() ;

Get the number of elements in the List:

List. Count () Return int value

E.g.：

int count = mList.Count();
Console.WriteLine("The num of elements in the list: " +count);

2. Advanced and powerful methods of List:

List used as an example:

string[] temArr = { Ha","Hunter", "Tom", "Lily", "Jay", "Jim", "Kuku", " "Locu" };

mList.AddRange( temArr);

List.Find method: Searches for elements that match the conditions defined by the specified predicate and returns the first matching element in the entire List.
public T Find(Predicate match);

Predicate is a delegate to the method. If the object passed to it matches the conditions defined in the delegate, the method returns true. The elements of the current List are passed to the Predicate delegate one by one and moved forward in the List, starting with the first element and ending with the last element. Processing stops when a match is found.

Predicate can be delegated to a function or a lambda expression:

Delegated to a lambda expression:

E.g.:

string listFind = mList.Find(name =>  //name是变量，代表的是mList
   {      //中元素，自己设定
   if (name.Length > 3)
   {
  return true;
   }
  return false;
});
Console.WriteLine(listFind);     //输出是Hunter

Delegated Give a function:

E.g.：
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 match);

用法与List.Find相同。

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

public bool TrueForAll(Predicate match);

委托给拉姆达表达式：

E.g.：

bool flag = mList.TrueForAll(name =>
{
    if (name.Length > 3)
    {
 return true;
    }
    else
    {
 return false;
    }
}
);
Console.WriteLine("True for all:  "+flag);  //flag值为false

委托给一个函数，这里用到上面的ListFind函数：

E.g.：

bool flag = mList.TrueForAll(ListFind); //委托给ListFind函数
Console.WriteLine("True for all: "+flag); //flag值为false

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

List.FindAll方法：检索与指定谓词所定义的条件相匹配的所有元素。

public List FindAll(Predicate match);

E.g.：

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的类型与List的类型一样

E.g.：

IEnumerable<string> takeList=  mList.Take(5);
   foreach (string s in takeList)
   {
  Console.WriteLine("element in takeList: " + s);
   }

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

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

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

public int RemoveAll(Predicate 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之后的元素。

List 是一个泛型链表...T表示节点元素类型
比如
List intList;表示一个元素为int的链表
intList.Add(34); //添加
intList.Remove(34);//删除
intList.RemoveAt(0); //删除位于某处的元素
intList.Count; //链表长度
还有Insert,Find,FindAll,Contains等方法,也有索引方法 intList[0] = 23;
1.减少了装箱拆箱
2.便于编译时检查数据类型

List