C# List<T>用法

所属命名空间：System.Collections.Generic     
using System.Collections.Generic;
public class List<T> : IList<T>, ICollection<T>, IEnumerable<T>, IList,
ICollection, IEnumerable
    List<T>类是  ArrayList 类的泛型等效类。 该类使用大小可按需动态增加的数
组实现  IList<T> 泛型接口。
 
 泛型的好处： 它为使用 c#语言编写面向对象程序增加了极大的效力和灵活
性。不会强行对值类型进行装箱和拆箱，或对引用类型进行向下强制类型转换，
所以性能得到提高。
 
性能注意事项：
在决定使用 IList<T> 还是使用 ArrayList 类（两者具有类似的功能）时，
记住IList<T> 类在大多数情况下执行得更好并且是类型安全的。
如果对 IList<T> 类的类型 T 使用引用类型，则两个类的行为是完全相同
的。但是，如果对类型 T 使用值类型，则需要考虑实现和装箱问题。
    用微软的话讲：
“添加到 ArrayList  中的任何引用或值类型都将隐式地向上强制转换为
Object。如果项是值类型，则必须在将其添加到列表中时进行装箱操作，在检
索时进行取消装箱操作。强制转换以及装箱和取消装箱操作都会降低性能；在必PS:如有问题请发送 E-mail 至：  [e-mail]
须对大型集合进行循环访问的情况下，装箱和取消装箱的影响非常明显。 ”
 
1、  List的基础、常用方法：
声明：
1、List<T> mList = new List<T>();    
T为列表中元素类型，现在以string类型作为例子
E.g.：  List<string> mList = new List<string>();
 
2、   List<T> testList =new List<T> (IEnumerable<T> collection);
      以一个集合作为参数创建List
       E.g.：
string[] temArr = { "Ha", "Hunter", "Tom", "Lily", "Jay", "Jim", "Kuku", "Locu" };
List<string> testList = new List<string>(temArr);
 
添加元素:   
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" };
   
 
3、Insert(int index, T item);    在index位置添加一个元素
E.g.：     mList.Insert(1, "Hei");
遍历List中元素:   
foreach (T element in mList)  T的类型与mList声明时一样
            {
                 Console.WriteLine(element);
            } PS:如有问题请发送 E-mail 至：  [e-mail]
E.g.：
foreach (string s in mList)
            {
                 Console.WriteLine(s);
            }
 
删除元素:
   1、  List. Remove(T item)       删除一个值
E.g.：    mList.Remove("Hunter");
    2、  List. RemoveAt(int index);   删除下标为index的元素
E.g.：     mList.RemoveAt(0);
                 3、  List. RemoveRange(int index, int count);   
从下标index开始，删除count个元素
       E.g.：    mList.RemoveRange(3, 2);
注：删除某元素后，其后面的元素下标自动跟进
 
判断某个元素是否在该List中：
List. Contains(T item)   返回true或false，很实用
E.g.：
if (mList.Contains("Hunter"))
            {
                 Console.WriteLine("There is Hunter in the list");
            }
             else
            {
                mList.Add("Hunter");
                 Console.WriteLine("Add Hunter successfully.");
            }
 
 
给List里面元素排序： PS:如有问题请发送 E-mail 至：  [e-mail]
List. Sort ()   默认是元素第一个字母按升序
E.g.：     mList.Sort();
给List里面元素顺序反转：
List. Reverse ()   可以与List. Sort ()配合使用，达到想要的效果
E.g.：     mList.Sort();
 
  List清空：List. Clear ()
E.g.：     mList.Clear();
  获得List中元素数目：
List. Count ()    返回int值
E.g.：
int count = mList.Count();
         Console.WriteLine("The num of elements in the list: " +count);
或者List.Count;
 
 
2、  List的进阶、强大方法：
举例用的 List：
string[] temArr = { Ha","Hunter", "Tom", "Lily", "Jay", "Jim", "Kuku", " "Locu" };
mList.AddRange(temArr);
 
 
List.Find 方法：搜索与指定谓词所定义的条件相匹配的元素，并返
回整个 List 中的第一个匹配元素。
public T Find(Predicate<T> match);
Predicate是对方法的委托，如果传递给它的对象与委托中定义的条件匹配，则该
方法返回 true。当前 List 的元素被逐个传递给Predicate委托，并在 List 中向PS:如有问题请发送 E-mail 至：  [e-mail]
前移动， 从第一个元素开始， 到最后一个元素结束。 当找到匹配项时处理即停止。  
Predicate  可以委托给一个函数或者一个拉姆达表达式
委托给拉姆达表达式：
E.g.：
              string listFind = mList.Find(name =>    //name是变量，代表的是mList
            {                               //中元素，自己设定
                 if (name.Length > 3)
                {
                     return true;
                }
                 return false;
            });
             Console.WriteLine(listFind);        //输出是Hunter
 
委托给一个函数：
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 中的最后一个匹配元素。 PS:如有问题请发送 E-mail 至：  [e-mail]
public T FindLast(Predicate<T> match);
用法与List.Find相同。
List.TrueForAll方法：  确定是否  List 中的每个元素都与指定的谓
词所定义的条件相匹配。
  public bool TrueForAll(Predicate<T> 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<T> FindAll(Predicate<T> match);
E.g.：
List<string> subList = mList.FindAll(ListFind); //委托给ListFind函数
          foreach (string s in subList)
         { PS:如有问题请发送 E-mail 至：  [e-mail]
              Console.WriteLine("element in subList: "+s);
         }
         这时subList存储的就是所有长度大于3的元素
 
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个
 
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的元素
 PS:如有问题请发送 E-mail 至：  [e-mail]
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之后的元素。
 
 
 
（PS:如有问题请发送 E-mail 至：  [e-mail]）
补充：比如要实现一个int类型的动态二维数组。
要增加一行就 matrix.add(new List<int>());
某行要增加数据就 matrix[n].add(i);但是不建议这么操作。
            List<List<int>> matrix = new List<List<int>>();
            matrix.Add(new List<int>());
            matrix[0].Add(1);
            Console.WriteLine(matrix[0][0]);
            Console.ReadKey();
List与数组的相互转换
1.从string[]转List<string>
例如：string[] str={“1”,”2”};
List <string> list=new List<string>(str);
2.从List<string>转string[] PS:如有问题请发送 E-mail 至：  [e-mail]
例如：List<string> list=new List<string>;
String[] str=list.ToArray();

还有一篇：http://www.cftea.com/c/2009/06/EYR713KMPJ2U1QZL.asp

来自：http://hi.baidu.com/laiyanbin2008/blog/item/07e61ddb20ec4e0a495403ad.html